dom/base/nsMimeTypeArray.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 sw=2 et tw=79: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsMimeTypeArray.h"
   8
   9 #include "mozilla/dom/MimeTypeArrayBinding.h"
  10 #include "mozilla/dom/MimeTypeBinding.h"
  11 #include "nsIDOMNavigator.h"
  12 #include "nsPluginArray.h"
  13 #include "nsIMIMEService.h"
  14 #include "nsIMIMEInfo.h"
  15 #include "Navigator.h"
  16 #include "nsServiceManagerUtils.h"
  17
  18 using namespace mozilla;
  19 using namespace mozilla::dom;
  20
  21 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsMimeTypeArray)
  22 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsMimeTypeArray)
  23 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsMimeTypeArray)
  24   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  25   NS_INTERFACE_MAP_ENTRY(nsISupports)
  26 NS_INTERFACE_MAP_END
  27
  28 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsMimeTypeArray,
  29                                       mWindow,
  30                                       mMimeTypes,
  31                                       mHiddenMimeTypes)
  32
  33 nsMimeTypeArray::nsMimeTypeArray(nsPIDOMWindow* aWindow)
  34   : mWindow(aWindow)
  35 {
  36 }
  37
  38 nsMimeTypeArray::~nsMimeTypeArray()
  39 {
  40 }
  41
  42 JSObject*
  43 nsMimeTypeArray::WrapObject(JSContext* aCx)
  44 {
  45   return MimeTypeArrayBinding::Wrap(aCx, this);
  46 }
  47
  48 void
  49 nsMimeTypeArray::Refresh()
  50 {
  51   mMimeTypes.Clear();
  52   mHiddenMimeTypes.Clear();
  53 }
  54
  55 nsPIDOMWindow*
  56 nsMimeTypeArray::GetParentObject() const
  57 {
  58   MOZ_ASSERT(mWindow);
  59   return mWindow;
  60 }
  61
  62 nsMimeType*
  63 nsMimeTypeArray::Item(uint32_t aIndex)
  64 {
  65   bool unused;
  66   return IndexedGetter(aIndex, unused);
  67 }
  68
  69 nsMimeType*
  70 nsMimeTypeArray::NamedItem(const nsAString& aName)
  71 {
  72   bool unused;
  73   return NamedGetter(aName, unused);
  74 }
  75
  76 nsMimeType*
  77 nsMimeTypeArray::IndexedGetter(uint32_t aIndex, bool &aFound)
  78 {
  79   aFound = false;
  80
  81   EnsurePluginMimeTypes();
  82
  83   if (aIndex >= mMimeTypes.Length()) {
  84     return nullptr;
  85   }
  86
  87   aFound = true;
  88
  89   return mMimeTypes[aIndex];
  90 }
  91
  92 static nsMimeType*
  93 FindMimeType(const nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes,
  94              const nsAString& aType)
  95 {
  96   for (uint32_t i = 0; i < aMimeTypes.Length(); ++i) {
  97     nsMimeType* mimeType = aMimeTypes[i];
  98     if (aType.Equals(mimeType->Type())) {
  99       return mimeType;
 100     }
 101   }
 102
 103   return nullptr;
 104 }
 105
 106 nsMimeType*
 107 nsMimeTypeArray::NamedGetter(const nsAString& aName, bool &aFound)
 108 {
 109   aFound = false;
 110
 111   EnsurePluginMimeTypes();
 112
 113   nsString lowerName(aName);
 114   ToLowerCase(lowerName);
 115
 116   nsMimeType* mimeType = FindMimeType(mMimeTypes, lowerName);
 117   if (!mimeType) {
 118     mimeType = FindMimeType(mHiddenMimeTypes, lowerName);
 119   }
 120
 121   if (mimeType) {
 122     aFound = true;
 123     return mimeType;
 124   }
 125
 126   // Now let's check with the MIME service.
 127   nsCOMPtr<nsIMIMEService> mimeSrv = do_GetService("@mozilla.org/mime;1");
 128   if (!mimeSrv) {
 129     return nullptr;
 130   }
 131
 132   nsCOMPtr<nsIMIMEInfo> mimeInfo;
 133   mimeSrv->GetFromTypeAndExtension(NS_ConvertUTF16toUTF8(lowerName),
 134                                    EmptyCString(), getter_AddRefs(mimeInfo));
 135   if (!mimeInfo) {
 136     return nullptr;
 137   }
 138
 139   // Now we check whether we can really claim to support this type
 140   nsHandlerInfoAction action = nsIHandlerInfo::saveToDisk;
 141   mimeInfo->GetPreferredAction(&action);
 142   if (action != nsIMIMEInfo::handleInternally) {
 143     bool hasHelper = false;
 144     mimeInfo->GetHasDefaultHandler(&hasHelper);
 145
 146     if (!hasHelper) {
 147       nsCOMPtr<nsIHandlerApp> helper;
 148       mimeInfo->GetPreferredApplicationHandler(getter_AddRefs(helper));
 149
 150       if (!helper) {
 151         // mime info from the OS may not have a PreferredApplicationHandler
 152         // so just check for an empty default description
 153         nsAutoString defaultDescription;
 154         mimeInfo->GetDefaultDescription(defaultDescription);
 155
 156         if (defaultDescription.IsEmpty()) {
 157           // no support; just leave
 158           return nullptr;
 159         }
 160       }
 161     }
 162   }
 163
 164   // If we got here, we support this type!  Say so.
 165   aFound = true;
 166
 167   // We don't want navigator.mimeTypes enumeration to expose MIME types with
 168   // application handlers, so add them to the list of hidden MIME types.
 169   nsMimeType *mt = new nsMimeType(mWindow, lowerName);
 170   mHiddenMimeTypes.AppendElement(mt);
 171
 172   return mt;
 173 }
 174
 175 bool
 176 nsMimeTypeArray::NameIsEnumerable(const nsAString& aName)
 177 {
 178   return true;
 179 }
 180
 181 uint32_t
 182 nsMimeTypeArray::Length()
 183 {
 184   EnsurePluginMimeTypes();
 185
 186   return mMimeTypes.Length();
 187 }
 188
 189 void
 190 nsMimeTypeArray::GetSupportedNames(unsigned, nsTArray< nsString >& aRetval)
 191 {
 192   EnsurePluginMimeTypes();
 193
 194   for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
 195     aRetval.AppendElement(mMimeTypes[i]->Type());
 196   }
 197 }
 198
 199 void
 200 nsMimeTypeArray::EnsurePluginMimeTypes()
 201 {
 202   if (!mMimeTypes.IsEmpty() || !mHiddenMimeTypes.IsEmpty() || !mWindow) {
 203     return;
 204   }
 205
 206   nsCOMPtr<nsIDOMNavigator> navigator;
 207   mWindow->GetNavigator(getter_AddRefs(navigator));
 208
 209   if (!navigator) {
 210     return;
 211   }
 212
 213   ErrorResult rv;
 214   nsPluginArray *pluginArray =
 215     static_cast<Navigator*>(navigator.get())->GetPlugins(rv);
 216   if (!pluginArray) {
 217     return;
 218   }
 219
 220   pluginArray->GetMimeTypes(mMimeTypes, mHiddenMimeTypes);
 221 }
 222
 223 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsMimeType, AddRef)
 224 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsMimeType, Release)
 225
 226 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsMimeType, mWindow, mPluginElement)
 227
 228 nsMimeType::nsMimeType(nsPIDOMWindow* aWindow, nsPluginElement* aPluginElement,
 229                        uint32_t aPluginTagMimeIndex, const nsAString& aType)
 230   : mWindow(aWindow),
 231     mPluginElement(aPluginElement),
 232     mPluginTagMimeIndex(aPluginTagMimeIndex),
 233     mType(aType)
 234 {
 235 }
 236
 237 nsMimeType::nsMimeType(nsPIDOMWindow* aWindow, const nsAString& aType)
 238   : mWindow(aWindow),
 239     mPluginElement(nullptr),
 240     mPluginTagMimeIndex(0),
 241     mType(aType)
 242 {
 243 }
 244
 245 nsMimeType::~nsMimeType()
 246 {
 247 }
 248
 249 nsPIDOMWindow*
 250 nsMimeType::GetParentObject() const
 251 {
 252   MOZ_ASSERT(mWindow);
 253   return mWindow;
 254 }
 255
 256 JSObject*
 257 nsMimeType::WrapObject(JSContext* aCx)
 258 {
 259   return MimeTypeBinding::Wrap(aCx, this);
 260 }
 261
 262 void
 263 nsMimeType::GetDescription(nsString& retval) const
 264 {
 265   retval.Truncate();
 266
 267   if (mPluginElement) {
 268     CopyUTF8toUTF16(mPluginElement->PluginTag()->
 269                     mMimeDescriptions[mPluginTagMimeIndex], retval);
 270   }
 271 }
 272
 273 nsPluginElement*
 274 nsMimeType::GetEnabledPlugin() const
 275 {
 276   return (mPluginElement && mPluginElement->PluginTag()->IsEnabled()) ?
 277     mPluginElement : nullptr;
 278 }
 279
 280 void
 281 nsMimeType::GetSuffixes(nsString& retval) const
 282 {
 283   retval.Truncate();
 284
 285   if (mPluginElement) {
 286     CopyUTF8toUTF16(mPluginElement->PluginTag()->
 287                     mExtensions[mPluginTagMimeIndex], retval);
 288   }
 289 }
 290
 291 void
 292 nsMimeType::GetType(nsString& aRetval) const
 293 {
 294   aRetval = mType;
 295 }