dom/base/nsPluginArray.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsPluginArray.h"
  40 #include "nsMimeTypeArray.h"
  41 #include "nsGlobalWindow.h"
  42 #include "nsIScriptGlobalObject.h"
  43 #include "nsIDOMNavigator.h"
  44 #include "nsIDOMMimeType.h"
  45 #include "nsIPluginHost.h"
  46 #include "nsIDocShell.h"
  47 #include "nsIWebNavigation.h"
  48 #include "nsDOMClassInfo.h"
  49 #include "nsPluginError.h"
  50 #include "nsContentUtils.h"
  51
  52 nsPluginArray::nsPluginArray(nsNavigator* navigator,
  53                              nsIDocShell *aDocShell)
  54 {
  55   nsresult rv;
  56   mNavigator = navigator; // don't ADDREF here, needed for parent of script object.
  57   mPluginHost = do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &rv);
  58   mPluginCount = 0;
  59   mPluginArray = nsnull;
  60   mDocShell = aDocShell;
  61 }
  62
  63 nsPluginArray::~nsPluginArray()
  64 {
  65   if (mPluginArray != nsnull) {
  66     for (PRUint32 i = 0; i < mPluginCount; i++) {
  67       NS_IF_RELEASE(mPluginArray[i]);
  68     }
  69     delete[] mPluginArray;
  70   }
  71 }
  72
  73 DOMCI_DATA(PluginArray, nsPluginArray)
  74
  75 // QueryInterface implementation for nsPluginArray
  76 NS_INTERFACE_MAP_BEGIN(nsPluginArray)
  77   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPluginArray)
  78   NS_INTERFACE_MAP_ENTRY(nsIDOMPluginArray)
  79   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PluginArray)
  80 NS_INTERFACE_MAP_END
  81
  82 NS_IMPL_ADDREF(nsPluginArray)
  83 NS_IMPL_RELEASE(nsPluginArray)
  84
  85 NS_IMETHODIMP
  86 nsPluginArray::GetLength(PRUint32* aLength)
  87 {
  88   if (AllowPlugins() && mPluginHost)
  89     return mPluginHost->GetPluginCount(aLength);
  90
  91   *aLength = 0;
  92   return NS_OK;
  93 }
  94
  95 PRBool
  96 nsPluginArray::AllowPlugins()
  97 {
  98   PRBool allowPlugins = PR_FALSE;
  99   if (mDocShell)
 100     if (NS_FAILED(mDocShell->GetAllowPlugins(&allowPlugins)))
 101       allowPlugins = PR_FALSE;
 102
 103   return allowPlugins;
 104 }
 105
 106 nsIDOMPlugin*
 107 nsPluginArray::GetItemAt(PRUint32 aIndex, nsresult* aResult)
 108 {
 109   *aResult = NS_OK;
 110
 111   if (!AllowPlugins())
 112     return nsnull;
 113
 114   if (mPluginArray == nsnull) {
 115     *aResult = GetPlugins();
 116     if (*aResult != NS_OK)
 117       return nsnull;
 118   }
 119
 120   return aIndex < mPluginCount ? mPluginArray[aIndex] : nsnull;
 121 }
 122
 123 NS_IMETHODIMP
 124 nsPluginArray::Item(PRUint32 aIndex, nsIDOMPlugin** aReturn)
 125 {
 126   nsresult rv;
 127
 128   NS_IF_ADDREF(*aReturn = GetItemAt(aIndex, &rv));
 129
 130   return rv;
 131 }
 132
 133 nsIDOMPlugin*
 134 nsPluginArray::GetNamedItem(const nsAString& aName, nsresult* aResult)
 135 {
 136   *aResult = NS_OK;
 137
 138   if (!AllowPlugins())
 139     return nsnull;
 140
 141   if (mPluginArray == nsnull) {
 142     *aResult = GetPlugins();
 143     if (*aResult != NS_OK)
 144       return nsnull;
 145   }
 146
 147   for (PRUint32 i = 0; i < mPluginCount; i++) {
 148     nsAutoString pluginName;
 149     nsIDOMPlugin* plugin = mPluginArray[i];
 150     if (plugin->GetName(pluginName) == NS_OK && pluginName.Equals(aName)) {
 151       return plugin;
 152     }
 153   }
 154
 155   return nsnull;
 156 }
 157
 158 NS_IMETHODIMP
 159 nsPluginArray::NamedItem(const nsAString& aName, nsIDOMPlugin** aReturn)
 160 {
 161   NS_PRECONDITION(nsnull != aReturn, "null arg");
 162
 163   nsresult rv;
 164
 165   NS_IF_ADDREF(*aReturn = GetNamedItem(aName, &rv));
 166
 167   return rv;
 168 }
 169
 170 nsresult
 171 nsPluginArray::GetPluginHost(nsIPluginHost** aPluginHost)
 172 {
 173   NS_ENSURE_ARG_POINTER(aPluginHost);
 174
 175   nsresult rv = NS_OK;
 176
 177   if (!mPluginHost) {
 178     mPluginHost = do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &rv);
 179
 180     if (NS_FAILED(rv)) {
 181       return rv;
 182     }
 183   }
 184
 185   *aPluginHost = mPluginHost;
 186   NS_IF_ADDREF(*aPluginHost);
 187
 188   return rv;
 189 }
 190
 191 void
 192 nsPluginArray::SetDocShell(nsIDocShell *aDocShell)
 193 {
 194   mDocShell = aDocShell;
 195 }
 196
 197 void
 198 nsPluginArray::Invalidate()
 199 {
 200   mDocShell = nsnull;
 201   mNavigator = nsnull;
 202 }
 203
 204 NS_IMETHODIMP
 205 nsPluginArray::Refresh(PRBool aReloadDocuments)
 206 {
 207   nsresult res = NS_OK;
 208   if (!AllowPlugins())
 209     return NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA;
 210
 211   if (!mPluginHost) {
 212     mPluginHost = do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &res);
 213   }
 214
 215   if(NS_FAILED(res)) {
 216     return res;
 217   }
 218
 219   // NS_ERROR_PLUGINS_PLUGINSNOTCHANGED on reloading plugins indicates
 220   // that plugins did not change and was not reloaded
 221   PRBool pluginsNotChanged = PR_FALSE;
 222   if(mPluginHost)
 223     pluginsNotChanged = (NS_ERROR_PLUGINS_PLUGINSNOTCHANGED == mPluginHost->ReloadPlugins(aReloadDocuments));
 224
 225   // no need to reload the page if plugins have not been changed
 226   // in fact, if we do reload we can hit recursive load problem, see bug 93351
 227   if(pluginsNotChanged)
 228     return res;
 229
 230   nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(mDocShell);
 231
 232   if (mPluginArray != nsnull) {
 233     for (PRUint32 i = 0; i < mPluginCount; i++)
 234       NS_IF_RELEASE(mPluginArray[i]);
 235
 236     delete[] mPluginArray;
 237   }
 238
 239   mPluginCount = 0;
 240   mPluginArray = nsnull;
 241
 242   if (mNavigator)
 243     mNavigator->RefreshMIMEArray();
 244
 245   if (aReloadDocuments && webNav)
 246     webNav->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
 247
 248   return res;
 249 }
 250
 251 nsresult
 252 nsPluginArray::GetPlugins()
 253 {
 254   nsresult rv = GetLength(&mPluginCount);
 255   if (NS_SUCCEEDED(rv)) {
 256     mPluginArray = new nsIDOMPlugin*[mPluginCount];
 257     if (!mPluginArray)
 258       return NS_ERROR_OUT_OF_MEMORY;
 259
 260     if (!mPluginCount)
 261       return NS_OK;
 262
 263     rv = mPluginHost->GetPlugins(mPluginCount, mPluginArray);
 264     if (NS_SUCCEEDED(rv)) {
 265       // need to wrap each of these with a nsPluginElement, which
 266       // is scriptable.
 267       for (PRUint32 i = 0; i < mPluginCount; i++) {
 268         nsIDOMPlugin* wrapper = new nsPluginElement(mPluginArray[i]);
 269         NS_IF_ADDREF(wrapper);
 270         mPluginArray[i] = wrapper;
 271       }
 272     } else {
 273       /* XXX this code is all broken. If GetPlugins fails, there's no contract
 274        *     explaining what should happen. Instead of deleting elements in an
 275        *     array of random pointers, we mark the array as 0 length.
 276        */
 277       mPluginCount = 0;
 278     }
 279   }
 280   return rv;
 281 }
 282
 283 //
 284
 285 nsPluginElement::nsPluginElement(nsIDOMPlugin* plugin)
 286 {
 287   mPlugin = plugin;  // don't AddRef, see nsPluginArray::Item.
 288   mMimeTypeCount = 0;
 289   mMimeTypeArray = nsnull;
 290 }
 291
 292 nsPluginElement::~nsPluginElement()
 293 {
 294   NS_IF_RELEASE(mPlugin);
 295
 296   if (mMimeTypeArray != nsnull) {
 297     for (PRUint32 i = 0; i < mMimeTypeCount; i++) {
 298       nsMimeType* mt = static_cast<nsMimeType*>(mMimeTypeArray[i]);
 299       if (mt) {
 300         mt->DetachPlugin();
 301         NS_RELEASE(mt);
 302       }
 303     }
 304     delete[] mMimeTypeArray;
 305   }
 306 }
 307
 308
 309 DOMCI_DATA(Plugin, nsPluginElement)
 310
 311 // QueryInterface implementation for nsPluginElement
 312 NS_INTERFACE_MAP_BEGIN(nsPluginElement)
 313   NS_INTERFACE_MAP_ENTRY(nsISupports)
 314   NS_INTERFACE_MAP_ENTRY(nsIDOMPlugin)
 315   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Plugin)
 316 NS_INTERFACE_MAP_END
 317
 318
 319 NS_IMPL_ADDREF(nsPluginElement)
 320 NS_IMPL_RELEASE(nsPluginElement)
 321
 322
 323 NS_IMETHODIMP
 324 nsPluginElement::GetDescription(nsAString& aDescription)
 325 {
 326   return mPlugin->GetDescription(aDescription);
 327 }
 328
 329 NS_IMETHODIMP
 330 nsPluginElement::GetFilename(nsAString& aFilename)
 331 {
 332   return mPlugin->GetFilename(aFilename);
 333 }
 334
 335 NS_IMETHODIMP
 336 nsPluginElement::GetVersion(nsAString& aVersion)
 337 {
 338   return mPlugin->GetVersion(aVersion);
 339 }
 340
 341 NS_IMETHODIMP
 342 nsPluginElement::GetName(nsAString& aName)
 343 {
 344   return mPlugin->GetName(aName);
 345 }
 346
 347 NS_IMETHODIMP
 348 nsPluginElement::GetLength(PRUint32* aLength)
 349 {
 350   return mPlugin->GetLength(aLength);
 351 }
 352
 353 nsIDOMMimeType*
 354 nsPluginElement::GetItemAt(PRUint32 aIndex, nsresult *aResult)
 355 {
 356   if (mMimeTypeArray == nsnull) {
 357     *aResult = GetMimeTypes();
 358     if (*aResult != NS_OK)
 359       return nsnull;
 360   }
 361
 362   if (aIndex >= mMimeTypeCount) {
 363     *aResult = NS_ERROR_FAILURE;
 364
 365     return nsnull;
 366   }
 367
 368   *aResult = NS_OK;
 369
 370   return mMimeTypeArray[aIndex];
 371 }
 372
 373 NS_IMETHODIMP
 374 nsPluginElement::Item(PRUint32 aIndex, nsIDOMMimeType** aReturn)
 375 {
 376   nsresult rv;
 377
 378   NS_IF_ADDREF(*aReturn = GetItemAt(aIndex, &rv));
 379
 380   return rv;
 381 }
 382
 383 nsIDOMMimeType*
 384 nsPluginElement::GetNamedItem(const nsAString& aName, nsresult *aResult)
 385 {
 386   if (mMimeTypeArray == nsnull) {
 387     *aResult = GetMimeTypes();
 388     if (*aResult != NS_OK)
 389       return nsnull;
 390   }
 391
 392   *aResult = NS_OK;
 393   for (PRUint32 i = 0; i < mMimeTypeCount; i++) {
 394     nsAutoString type;
 395     nsIDOMMimeType* mimeType = mMimeTypeArray[i];
 396     if (mimeType->GetType(type) == NS_OK && type.Equals(aName)) {
 397       return mimeType;
 398     }
 399   }
 400
 401   return nsnull;
 402 }
 403
 404 NS_IMETHODIMP
 405 nsPluginElement::NamedItem(const nsAString& aName, nsIDOMMimeType** aReturn)
 406 {
 407   nsresult rv;
 408
 409   NS_IF_ADDREF(*aReturn = GetNamedItem(aName, &rv));
 410
 411   return rv;
 412 }
 413
 414 nsresult
 415 nsPluginElement::GetMimeTypes()
 416 {
 417   nsresult rv = mPlugin->GetLength(&mMimeTypeCount);
 418   if (rv == NS_OK) {
 419     mMimeTypeArray = new nsIDOMMimeType*[mMimeTypeCount];
 420     if (mMimeTypeArray == nsnull)
 421       return NS_ERROR_OUT_OF_MEMORY;
 422     for (PRUint32 i = 0; i < mMimeTypeCount; i++) {
 423       nsCOMPtr<nsIDOMMimeType> mimeType;
 424       rv = mPlugin->Item(i, getter_AddRefs(mimeType));
 425       if (rv != NS_OK)
 426         break;
 427       mimeType = new nsMimeType(this, mimeType);
 428       NS_IF_ADDREF(mMimeTypeArray[i] = mimeType);
 429     }
 430   }
 431   return rv;
 432 }