sbMediacoreTypeSniffer.cpp
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set sw=2 :miv */
3 /*
4  *=BEGIN SONGBIRD GPL
5  *
6  * This file is part of the Songbird web player.
7  *
8  * Copyright(c) 2005-2010 POTI, Inc.
9  * http://www.songbirdnest.com
10  *
11  * This file may be licensed under the terms of of the
12  * GNU General Public License Version 2 (the ``GPL'').
13  *
14  * Software distributed under the License is distributed
15  * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
16  * express or implied. See the GPL for the specific language
17  * governing rights and limitations.
18  *
19  * You should have received a copy of the GPL along with this
20  * program. If not, go to http://www.gnu.org/licenses/gpl.html
21  * or write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  *=END SONGBIRD GPL
25  */
26 
27 #include "sbMediacoreTypeSniffer.h"
28 
29 #include <nsIURI.h>
30 #include <nsIURL.h>
31 
32 #include <nsAutoLock.h>
33 #include <nsArrayUtils.h>
34 #include <nsComponentManagerUtils.h>
35 #include <nsMemory.h>
36 #include <nsServiceManagerUtils.h>
37 #include <nsStringGlue.h>
38 #include <nsTArray.h>
39 
40 #include <sbIMediacoreCapabilities.h>
41 #include <sbIMediacoreFactory.h>
42 #include <sbIPlaylistReader.h>
45 #include <sbStringUtils.h>
46 
47 const char *gBannedWebExtensions[] = {"htm", "html", "php", "php3"};
48 const PRUint16 gBannedWebExtensionsSize =
49  sizeof(gBannedWebExtensions) / sizeof(gBannedWebExtensions[0]);
50 
53 
55 : mMonitor(nsnull)
56 {
57 }
58 
59 sbMediacoreTypeSniffer::~sbMediacoreTypeSniffer()
60 {
61  if(mMonitor) {
62  nsAutoMonitor::DestroyMonitor(mMonitor);
63  }
64 }
65 
66 nsresult
68 {
69  mMonitor = nsAutoMonitor::NewMonitor("sbMediacoreTypeSniffer::mMonitor");
70  NS_ENSURE_TRUE(mMonitor, NS_ERROR_OUT_OF_MEMORY);
71 
72  nsresult rv = NS_ERROR_UNEXPECTED;
73 
74  nsCOMPtr<sbIMediacoreFactoryRegistrar> factoryRegistrar =
75  do_GetService(SB_MEDIACOREMANAGER_CONTRACTID, &rv);
76  NS_ENSURE_SUCCESS(rv, rv);
77 
78  factoryRegistrar.swap(mFactoryRegistrar);
79 
80  PRBool success = mAudioExtensions.Init();
81  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
82 
83  success = mVideoExtensions.Init();
84  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
85 
86  success = mImageExtensions.Init();
87  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
88 
89  success = mPlaylistExtensions.Init();
90  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
91 
92  success = mBannedWebExtensions.Init();
93  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
94 
95  success = mAllExtensions.Init();
96  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);
97 
98  nsCOMPtr<nsIArray> factories;
99  rv = mFactoryRegistrar->GetFactories(getter_AddRefs(factories));
100  NS_ENSURE_SUCCESS(rv, rv);
101 
102  PRUint32 length = 0;
103  rv = factories->GetLength(&length);
104  NS_ENSURE_SUCCESS(rv, rv);
105 
106  for(PRUint32 current = 0; current < length; ++current) {
107  nsCOMPtr<sbIMediacoreFactory> factory = do_QueryElementAt(factories,
108  current,
109  &rv);
110  NS_ENSURE_SUCCESS(rv, rv);
111 
112  nsCOMPtr<sbIMediacoreCapabilities> caps;
113  rv = factory->GetCapabilities(getter_AddRefs(caps));
114  NS_ENSURE_SUCCESS(rv, rv);
115 
116  // Audio extensions
117  nsCOMPtr<nsIStringEnumerator> extensions;
118  rv = caps->GetAudioExtensions(getter_AddRefs(extensions));
119  NS_ENSURE_SUCCESS(rv, rv);
120 
121  PRBool hasMore = PR_FALSE;
122  while(NS_SUCCEEDED(extensions->HasMore(&hasMore)) &&
123  hasMore) {
124  nsString extension;
125 
126  rv = extensions->GetNext(extension);
127  NS_ENSURE_SUCCESS(rv, rv);
128 
129  NS_ConvertUTF16toUTF8 theExtension(extension);
130  nsCStringHashKey *hashKey = mAudioExtensions.PutEntry(theExtension);
131  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
132 
133  hashKey = mAllExtensions.PutEntry(theExtension);
134  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
135  }
136 
137  // Video extensions
138  rv = caps->GetVideoExtensions(getter_AddRefs(extensions));
139  NS_ENSURE_SUCCESS(rv, rv);
140 
141  hasMore = PR_FALSE;
142  while(NS_SUCCEEDED(extensions->HasMore(&hasMore)) &&
143  hasMore) {
144  nsString extension;
145 
146  rv = extensions->GetNext(extension);
147  NS_ENSURE_SUCCESS(rv, rv);
148 
149  NS_ConvertUTF16toUTF8 theExtension(extension);
150  nsCStringHashKey *hashKey = mVideoExtensions.PutEntry(theExtension);
151  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
152 
153  hashKey = mAllExtensions.PutEntry(theExtension);
154  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
155  }
156 
157  // Image extensions
158  rv = caps->GetImageExtensions(getter_AddRefs(extensions));
159  NS_ENSURE_SUCCESS(rv, rv);
160 
161  hasMore = PR_FALSE;
162  while(NS_SUCCEEDED(extensions->HasMore(&hasMore)) &&
163  hasMore) {
164  nsString extension;
165 
166  rv = extensions->GetNext(extension);
167  NS_ENSURE_SUCCESS(rv, rv);
168 
169  NS_ConvertUTF16toUTF8 theExtension(extension);
170  nsCStringHashKey *hashKey = mImageExtensions.PutEntry(theExtension);
171  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
172 
173  hashKey = mAllExtensions.PutEntry(theExtension);
174  NS_ENSURE_TRUE(hashKey, NS_ERROR_OUT_OF_MEMORY);
175  }
176  }
177 
178  // Get the playlist extensions from the playlist reader manager
179  nsCOMPtr<sbIPlaylistReaderManager> readerManager;
180  if (NS_IsMainThread()) {
181  readerManager = do_GetService(
182  "@songbirdnest.com/Songbird/PlaylistReaderManager;1",
183  &rv);
184  NS_ENSURE_SUCCESS(rv, rv);
185  }
186  else {
187  readerManager = do_ProxiedGetService(
188  "@songbirdnest.com/Songbird/PlaylistReaderManager;1",
189  &rv);
190  NS_ENSURE_SUCCESS(rv, rv);
191  }
192 
193  length = 0;
194  PRUnichar **extensions = nsnull;
195 
196  rv = readerManager->SupportedFileExtensions(&length, &extensions);
197  NS_ENSURE_SUCCESS(rv, rv);
198 
199  for(PRUint32 current = 0; current < length; ++current) {
200  NS_ConvertUTF16toUTF8 theExtension(extensions[current]);
201 
202  mPlaylistExtensions.PutEntry(theExtension);
203  mAllExtensions.PutEntry(theExtension);
204  }
205 
206  NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(length, extensions);
207  NS_ENSURE_TRUE(length == mPlaylistExtensions.Count(), NS_ERROR_UNEXPECTED);
208 
209  for(PRUint16 current = 0; current < gBannedWebExtensionsSize; ++current) {
210  mBannedWebExtensions.PutEntry(nsDependentCString(gBannedWebExtensions[current]));
211  }
212 
213  return NS_OK;
214 }
215 
216 
217 nsresult
218 sbMediacoreTypeSniffer::GetFileExtensionFromURI(nsIURI* aURI,
219  nsACString& _retval)
220 {
221  NS_ENSURE_ARG_POINTER(aURI);
222 
223  nsCAutoString strExtension;
224 
225  nsresult rv;
226  nsCOMPtr<nsIURL> url = do_QueryInterface(aURI, &rv);
227  if (NS_SUCCEEDED(rv)) {
228  // Try the easy way...
229  rv = url->GetFileExtension(strExtension);
230  NS_ENSURE_SUCCESS(rv, rv);
231  }
232  else {
233  // Try the hard way...
234  nsCAutoString spec;
235  rv = aURI->GetSpec(spec);
236  NS_ENSURE_SUCCESS(rv, rv);
237 
238  PRInt32 index = spec.RFindChar('.');
239  if (index >= 0) {
240  strExtension.Assign(StringTail(spec, spec.Length() -1 - index));
241  }
242  }
243 
244  if (strExtension.IsEmpty()) {
245  _retval.Truncate();
246  return NS_OK;
247  }
248 
249  // Strip '.' from the beginning and end, if it exists
250  strExtension.Trim(".");
251 
252  ToLowerCase(strExtension, _retval);
253 
254  return NS_OK;
255 }
256 
257 NS_IMETHODIMP
258 sbMediacoreTypeSniffer::IsValidMediaURL(nsIURI *aURL,
259  PRBool *_retval)
260 {
261  NS_ENSURE_ARG_POINTER(aURL);
262  NS_ENSURE_ARG_POINTER(_retval);
263 
264  *_retval = PR_TRUE;
265 
266  nsCString fileExtension;
267  nsresult rv = GetFileExtensionFromURI(aURL, fileExtension);
268  NS_ENSURE_SUCCESS(rv, rv);
269 
270  // The quick and easy way. Verify against file extension if available.
271  if(!fileExtension.IsEmpty()) {
272 
273  nsAutoMonitor mon(mMonitor);
274 
275  if(mAudioExtensions.GetEntry(fileExtension)) {
276  return NS_OK;
277  }
278 
279  if(mVideoExtensions.GetEntry(fileExtension)) {
280  return NS_OK;
281  }
282 
283  if(mImageExtensions.GetEntry(fileExtension)) {
284  return NS_OK;
285  }
286 
287  // Exhausted all possibilities.
288  *_retval = PR_FALSE;
289 
290  return NS_OK;
291  }
292 
293  // XXXAus: For the time being, if there's no extension we'll pretend like it
294  // is not media.
295  *_retval = PR_FALSE;
296 
297  // XXXAus: Below are comments for implementing further functionality.
298  // Looks like we'll have to crack open the file or connect to the server
299  // to have a look at the content type.
300 
301  return NS_OK;
302 }
303 
304 NS_IMETHODIMP
305 sbMediacoreTypeSniffer::IsValidAudioURL(nsIURI *aURL, PRBool *aRetVal)
306 {
307  NS_ENSURE_ARG_POINTER(aURL);
308  NS_ENSURE_ARG_POINTER(aRetVal);
309 
310  *aRetVal = PR_TRUE;
311 
312  nsCString fileExtension;
313  nsresult rv = GetFileExtensionFromURI(aURL, fileExtension);
314  NS_ENSURE_SUCCESS(rv, rv);
315 
316  if (!fileExtension.IsEmpty()) {
317  nsAutoMonitor mon(mMonitor);
318 
319  if (mAudioExtensions.GetEntry(fileExtension)) {
320  return NS_OK;
321  }
322 
323  *aRetVal = PR_FALSE;
324  }
325 
326  // Assume that this URL is not an audio file.
327  *aRetVal = PR_FALSE;
328  return NS_OK;
329 }
330 
331 NS_IMETHODIMP
332 sbMediacoreTypeSniffer::IsValidVideoURL(nsIURI *aURL,
333  PRBool *_retval)
334 {
335  NS_ENSURE_ARG_POINTER(aURL);
336  NS_ENSURE_ARG_POINTER(_retval);
337 
338  *_retval = PR_TRUE;
339 
340  nsCString fileExtension;
341  nsresult rv = GetFileExtensionFromURI(aURL, fileExtension);
342  NS_ENSURE_SUCCESS(rv, rv);
343 
344  // The quick and easy way. Verify against file extension if available.
345  if(!fileExtension.IsEmpty()) {
346 
347  nsAutoMonitor mon(mMonitor);
348 
349  if(mVideoExtensions.GetEntry(fileExtension)) {
350  return NS_OK;
351  }
352 
353  *_retval = PR_FALSE;
354 
355  return NS_OK;
356  }
357 
358  // XXXAus: For the time being, if there's no extension we'll pretend like there
359  // is no video.
360  *_retval = PR_FALSE;
361 
362  // XXXAus: Below are comments for implementing further functionality.
363  // Looks like we'll have to crack open the file or connect to the server
364  // to have a look at the content type.
365 
366  return NS_OK;
367 }
368 
369 NS_IMETHODIMP
370 sbMediacoreTypeSniffer::IsValidPlaylistURL(nsIURI *aURL,
371  PRBool *_retval)
372 {
373  NS_ENSURE_ARG_POINTER(aURL);
374  NS_ENSURE_ARG_POINTER(_retval);
375 
376  *_retval = PR_TRUE;
377 
378  nsCString fileExtension;
379  nsresult rv = GetFileExtensionFromURI(aURL, fileExtension);
380  NS_ENSURE_SUCCESS(rv, rv);
381 
382  // The quick and easy way. Verify against file extension if available.
383  if(!fileExtension.IsEmpty()) {
384 
385  nsAutoMonitor mon(mMonitor);
386 
387  if(mPlaylistExtensions.GetEntry(fileExtension)) {
388  return NS_OK;
389  }
390 
391  *_retval = PR_FALSE;
392 
393  return NS_OK;
394  }
395 
396  // XXXAus: For the time being, if there's no extension we'll pretend like this
397  // is _not_ a playlist.
398  *_retval = PR_FALSE;
399 
400  // XXXAus: Below are comments for implementing further functionality.
401  // Looks like we'll have to crack open the file or connect to the server
402  // to have a look at the content type.
403 
404  return NS_OK;
405 }
406 
407 NS_IMETHODIMP
408 sbMediacoreTypeSniffer::IsValidImageURL(nsIURI *aURL, PRBool *aRetVal)
409 {
410  NS_ENSURE_ARG_POINTER(aURL);
411  NS_ENSURE_ARG_POINTER(aRetVal);
412 
413  *aRetVal = PR_TRUE;
414 
415  nsCString fileExtension;
416  GetFileExtensionFromURI(aURL, fileExtension);
417 
418  if (!fileExtension.IsEmpty()) {
419  nsAutoMonitor mon(mMonitor);
420 
421  if (mImageExtensions.GetEntry(fileExtension)) {
422  return NS_OK;
423  }
424 
425  *aRetVal = PR_FALSE;
426  }
427 
428  // Assume that this URL is not an image file.
429  *aRetVal = PR_FALSE;
430  return NS_OK;
431 }
432 
433 NS_IMETHODIMP
434 sbMediacoreTypeSniffer::IsValidWebSafePlaylistURL(nsIURI *aURL,
435  PRBool *_retval)
436 {
437  NS_ENSURE_ARG_POINTER(aURL);
438  NS_ENSURE_ARG_POINTER(_retval);
439 
440  *_retval = PR_FALSE;
441 
442  nsCString fileExtension;
443  nsresult rv = GetFileExtensionFromURI(aURL, fileExtension);
444  NS_ENSURE_SUCCESS(rv, rv);
445 
446  nsAutoMonitor mon(mMonitor);
447 
448  if(!fileExtension.IsEmpty() &&
449  !mBannedWebExtensions.GetEntry(fileExtension)) {
450 
451  if(mPlaylistExtensions.GetEntry(fileExtension)) {
452  *_retval = PR_TRUE;
453  }
454  }
455 
456  return NS_OK;
457 }
458 
459 template<class EntryType>
460 PLDHashOperator PR_CALLBACK EnumerateAllExtensions(EntryType* aEntry,
461  void *aUserArg)
462 {
463  NS_ENSURE_TRUE(aEntry, PL_DHASH_STOP);
464  NS_ENSURE_TRUE(aUserArg, PL_DHASH_STOP);
465 
466  nsTArray<nsString> *aArray = reinterpret_cast<nsTArray<nsString> *>(aUserArg);
467 
468  nsString *elem =
469  aArray->AppendElement(NS_ConvertUTF8toUTF16(aEntry->GetKey()));
470  NS_ENSURE_TRUE(elem, PL_DHASH_STOP);
471 
472  return PL_DHASH_NEXT;
473 }
474 
475 NS_IMETHODIMP
476 sbMediacoreTypeSniffer::GetAudioFileExtensions(nsIStringEnumerator **_retval)
477 {
478  NS_ENSURE_ARG_POINTER(_retval);
479 
480  nsTArray<nsString> allExtensions;
481 
482  nsAutoMonitor mon(mMonitor);
483  PRUint32 count = mAudioExtensions.EnumerateEntries(EnumerateAllExtensions<nsCStringHashKey>,
484  &allExtensions);
485  NS_ENSURE_TRUE(count == mAudioExtensions.Count(), NS_ERROR_UNEXPECTED);
486 
487  nsCOMPtr<nsIStringEnumerator> allExtensionsEnum =
488  new sbTArrayStringEnumerator(&allExtensions);
489  NS_ENSURE_TRUE(allExtensionsEnum, NS_ERROR_OUT_OF_MEMORY);
490 
491  allExtensionsEnum.forget(_retval);
492 
493  return NS_OK;
494 }
495 
496 NS_IMETHODIMP
497 sbMediacoreTypeSniffer::GetVideoFileExtensions(nsIStringEnumerator **_retval)
498 {
499  NS_ENSURE_ARG_POINTER(_retval);
500 
501  nsTArray<nsString> allExtensions;
502 
503  nsAutoMonitor mon(mMonitor);
504  PRUint32 count = mVideoExtensions.EnumerateEntries(EnumerateAllExtensions<nsCStringHashKey>,
505  &allExtensions);
506  NS_ENSURE_TRUE(count == mVideoExtensions.Count(), NS_ERROR_UNEXPECTED);
507 
508  nsCOMPtr<nsIStringEnumerator> allExtensionsEnum =
509  new sbTArrayStringEnumerator(&allExtensions);
510  NS_ENSURE_TRUE(allExtensionsEnum, NS_ERROR_OUT_OF_MEMORY);
511 
512  allExtensionsEnum.forget(_retval);
513 
514  return NS_OK;
515 }
516 
517 NS_IMETHODIMP
518 sbMediacoreTypeSniffer::GetPlaylistFileExtensions(nsIStringEnumerator **_retval)
519 {
520  NS_ENSURE_ARG_POINTER(_retval);
521 
522  nsTArray<nsString> allExtensions;
523 
524  nsAutoMonitor mon(mMonitor);
525  PRUint32 count = mPlaylistExtensions.EnumerateEntries(EnumerateAllExtensions<nsCStringHashKey>,
526  &allExtensions);
527  NS_ENSURE_TRUE(count == mPlaylistExtensions.Count(), NS_ERROR_UNEXPECTED);
528 
529  nsCOMPtr<nsIStringEnumerator> allExtensionsEnum =
530  new sbTArrayStringEnumerator(&allExtensions);
531  NS_ENSURE_TRUE(allExtensionsEnum, NS_ERROR_OUT_OF_MEMORY);
532 
533  allExtensionsEnum.forget(_retval);
534 
535  return NS_OK;
536 }
537 
538 NS_IMETHODIMP
539 sbMediacoreTypeSniffer::GetImageFileExtensions(nsIStringEnumerator **_retval)
540 {
541  NS_ENSURE_ARG_POINTER(_retval);
542 
543  nsTArray<nsString> allExtensions;
544 
545  nsAutoMonitor mon(mMonitor);
546  if (mImageExtensions.Count()) {
547  PRUint32 count = mImageExtensions.EnumerateEntries
548  (EnumerateAllExtensions<nsCStringHashKey>, &allExtensions);
549  NS_ENSURE_TRUE(count == mImageExtensions.Count(), NS_ERROR_UNEXPECTED);
550  }
551  else {
552  // Use a hard coded list if image extension list is empty
553  allExtensions.AppendElement(NS_LITERAL_STRING("gif"));
554  allExtensions.AppendElement(NS_LITERAL_STRING("jpg"));
555  allExtensions.AppendElement(NS_LITERAL_STRING("jpeg"));
556  allExtensions.AppendElement(NS_LITERAL_STRING("png"));
557  allExtensions.AppendElement(NS_LITERAL_STRING("bmp"));
558  }
559 
560  nsCOMPtr<nsIStringEnumerator> allExtensionsEnum =
561  new sbTArrayStringEnumerator(&allExtensions);
562  NS_ENSURE_TRUE(allExtensionsEnum, NS_ERROR_OUT_OF_MEMORY);
563 
564  allExtensionsEnum.forget(_retval);
565 
566  return NS_OK;
567 }
568 
569 NS_IMETHODIMP
570 sbMediacoreTypeSniffer::GetMediaFileExtensions(nsIStringEnumerator **_retval)
571 {
572  NS_ENSURE_ARG_POINTER(_retval);
573 
574  nsTArray<nsString> allExtensions;
575 
576  nsAutoMonitor mon(mMonitor);
577  PRUint32 count = mAudioExtensions.EnumerateEntries(EnumerateAllExtensions<nsCStringHashKey>,
578  &allExtensions);
579  NS_ENSURE_TRUE(count == mAudioExtensions.Count(), NS_ERROR_UNEXPECTED);
580 
581  count = mVideoExtensions.EnumerateEntries(EnumerateAllExtensions<nsCStringHashKey>,
582  &allExtensions);
583  NS_ENSURE_TRUE(count == mVideoExtensions.Count(), NS_ERROR_UNEXPECTED);
584 
585  nsCOMPtr<nsIStringEnumerator> allExtensionsEnum =
586  new sbTArrayStringEnumerator(&allExtensions);
587  NS_ENSURE_TRUE(allExtensionsEnum, NS_ERROR_OUT_OF_MEMORY);
588 
589  allExtensionsEnum.forget(_retval);
590 
591  return NS_OK;
592 }
593 
594 NS_IMETHODIMP
595 sbMediacoreTypeSniffer::GetUnsupportedVideoFileExtensions(
596  nsIStringEnumerator **aOutStringEnum)
597 {
598  NS_ENSURE_ARG_POINTER(aOutStringEnum);
599 
600  static const char defaultKnownVideoExtensions[] =
601  "3g2,3gp,3gp2,3gpp,asf,avi,divx,dv,dvr-ms,flc,flh,fli,flv,flx,m1pg,"
602  "m1v,m2t,m2ts,m2v,mj2,mjp,mjpg,mkv,moov,mov,movie,mp2v,mp4v,mpe,mpeg,"
603  "mpg,mpg2,mpv,mpv2,msdvd,mxf,nsv,ogm,qt,qtch,qtl,qtz,rm,rmvb,rv,smv,"
604  "ts,vc1,vob,vp6,vp7,wm,wmv,xvid";
605 
606  nsCString knownExtensions;
607  knownExtensions.Assign(defaultKnownVideoExtensions);
608 
609  nsTArray<nsCString> knownExtensionsStrArray;
610  nsCString_Split(knownExtensions,
611  NS_LITERAL_CSTRING(","),
612  knownExtensionsStrArray);
613 
614  nsTArray<nsString> unsupportedExtensionsStrArray;
615  for (PRUint32 i = 0; i < knownExtensionsStrArray.Length(); i++) {
616  // Validate the current extension against the video and audio known
617  // supported extension list.
618  nsAutoMonitor mon(mMonitor);
619 
620  if (mVideoExtensions.GetEntry(knownExtensionsStrArray[i])) {
621  continue;
622  }
623 
624  // This isn't a supported extension.
625  unsupportedExtensionsStrArray.AppendElement(
626  NS_ConvertUTF8toUTF16(knownExtensionsStrArray[i]));
627  }
628 
629  nsCOMPtr<nsIStringEnumerator> extensionsEnum =
630  new sbTArrayStringEnumerator(&unsupportedExtensionsStrArray);
631  NS_ENSURE_TRUE(extensionsEnum, NS_ERROR_OUT_OF_MEMORY);
632 
633  extensionsEnum.forget(aOutStringEnum);
634  return NS_OK;
635 }
636 
NS_IMPL_THREADSAFE_ISUPPORTS1(sbMediacoreTypeSniffer, sbIMediacoreTypeSniffer) sbMediacoreTypeSniffer
nsTHashtable< nsCStringHashKey > mBannedWebExtensions
return NS_OK
const PRUint16 gBannedWebExtensionsSize
return elem[name]
nsTHashtable< nsCStringHashKey > mAudioExtensions
nsTHashtable< nsCStringHashKey > mPlaylistExtensions
PLDHashOperator PR_CALLBACK EnumerateAllExtensions(EntryType *aEntry, void *aUserArg)
var count
Definition: test_bug7406.js:32
const sbCreateProxiedComponent do_ProxiedGetService(const nsCID &aCID, nsresult *error=0)
const char * gBannedWebExtensions[]
nsCOMPtr< sbIMediacoreFactoryRegistrar > mFactoryRegistrar
nsTHashtable< nsCStringHashKey > mImageExtensions
nsTHashtable< nsCStringHashKey > mAllExtensions
void nsCString_Split(const nsACString &aString, const nsACString &aDelimiter, nsTArray< nsCString > &aSubStringArray)
function url(spec)
StringArrayEnumerator prototype hasMore
#define SB_MEDIACOREMANAGER_CONTRACTID
_getSelectedPageStyle s i
nsTHashtable< nsCStringHashKey > mVideoExtensions