dom/src/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 "nsIServiceManager.h"
  46 #include "nsIPluginHost.h"
  47 #include "nsIDocShell.h"
  48 #include "nsIWebNavigation.h"
  49 #include "nsDOMClassInfo.h"
  50 #include "nsPluginError.h"
  51 #include "nsIComponentRegistrar.h"
  52 #include "nsContentUtils.h"
  53
  54 static NS_DEFINE_CID(kPluginManagerCID, NS_PLUGINMANAGER_CID);
  55
  56 nsPluginArray::nsPluginArray(nsNavigator* navigator,
  57                              nsIDocShell *aDocShell)
  58 {
  59   nsresult rv;
  60   mNavigator = navigator; // don't ADDREF here, needed for parent of script object.
  61   mPluginHost = do_GetService(kPluginManagerCID, &rv);
  62   mPluginCount = 0;
  63   mPluginArray = nsnull;
  64   mDocShell = aDocShell;
  65 }
  66
  67 nsPluginArray::~nsPluginArray()
  68 {
  69   if (mPluginArray != nsnull) {
  70     for (PRUint32 i = 0; i < mPluginCount; i++) {
  71       NS_IF_RELEASE(mPluginArray[i]);
  72     }
  73     delete[] mPluginArray;
  74   }
  75 }
  76
  77 // QueryInterface implementation for nsPluginArray
  78 NS_INTERFACE_MAP_BEGIN(nsPluginArray)
  79   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMPluginArray)
  80   NS_INTERFACE_MAP_ENTRY(nsIDOMPluginArray)
  81   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(PluginArray)
  82 NS_INTERFACE_MAP_END
  83
  84 NS_IMPL_ADDREF(nsPluginArray)
  85 NS_IMPL_RELEASE(nsPluginArray)
  86
  87 NS_IMETHODIMP
  88 nsPluginArray::GetLength(PRUint32* aLength)
  89 {
  90   if (AllowPlugins() && mPluginHost)
  91     return mPluginHost->GetPluginCount(aLength);
  92
  93   *aLength = 0;
  94   return NS_OK;
  95 }
  96
  97 PRBool
  98 nsPluginArray::AllowPlugins()
  99 {
 100   PRBool allowPlugins = PR_FALSE;
 101   if (mDocShell)
 102     if (NS_FAILED(mDocShell->GetAllowPlugins(&allowPlugins)))
 103       allowPlugins = PR_FALSE;
 104
 105   return allowPlugins;
 106 }
 107
 108 nsIDOMPlugin*
 109 nsPluginArray::GetItemAt(PRUint32 aIndex, nsresult* aResult)
 110 {
 111   *aResult = NS_OK;
 112
 113   if (!AllowPlugins())
 114     return nsnull;
 115
 116   if (mPluginArray == nsnull) {
 117     *aResult = GetPlugins();
 118     if (*aResult != NS_OK)
 119       return nsnull;
 120   }
 121
 122   return aIndex < mPluginCount ? mPluginArray[aIndex] : nsnull;
 123 }
 124
 125 NS_IMETHODIMP
 126 nsPluginArray::Item(PRUint32 aIndex, nsIDOMPlugin** aReturn)
 127 {
 128   nsresult rv;
 129
 130   NS_IF_ADDREF(*aReturn = GetItemAt(aIndex, &rv));
 131
 132   return rv;
 133 }
 134
 135 nsIDOMPlugin*
 136 nsPluginArray::GetNamedItem(const nsAString& aName, nsresult* aResult)
 137 {
 138   *aResult = NS_OK;
 139
 140   if (!AllowPlugins())
 141     return nsnull;
 142
 143   if (mPluginArray == nsnull) {
 144     *aResult = GetPlugins();
 145     if (*aResult != NS_OK)
 146       return nsnull;
 147   }
 148
 149   for (PRUint32 i = 0; i < mPluginCount; i++) {
 150     nsAutoString pluginName;
 151     nsIDOMPlugin* plugin = mPluginArray[i];
 152     if (plugin->GetName(pluginName) == NS_OK && pluginName.Equals(aName)) {
 153       return plugin;
 154     }
 155   }
 156
 157   return nsnull;
 158 }
 159
 160 NS_IMETHODIMP
 161 nsPluginArray::NamedItem(const nsAString& aName, nsIDOMPlugin** aReturn)
 162 {
 163   NS_PRECONDITION(nsnull != aReturn, "null arg");
 164
 165   nsresult rv;
 166
 167   NS_IF_ADDREF(*aReturn = GetNamedItem(aName, &rv));
 168
 169   return rv;
 170 }
 171
 172 nsresult
 173 nsPluginArray::GetPluginHost(nsIPluginHost** aPluginHost)
 174 {
 175   NS_ENSURE_ARG_POINTER(aPluginHost);
 176
 177   nsresult rv = NS_OK;
 178
 179   if (!mPluginHost) {
 180     mPluginHost = do_GetService(kPluginManagerCID, &rv);
 181
 182     if (NS_FAILED(rv)) {
 183       return rv;
 184     }
 185   }
 186
 187   *aPluginHost = mPluginHost;
 188   NS_IF_ADDREF(*aPluginHost);
 189
 190   return rv;
 191 }
 192
 193 void
 194 nsPluginArray::SetDocShell(nsIDocShell* aDocShell)
 195 {
 196   mDocShell = aDocShell;
 197 }
 198
 199 NS_IMETHODIMP
 200 nsPluginArray::Refresh(PRBool aReloadDocuments)
 201 {
 202   nsresult res = NS_OK;
 203   if (!AllowPlugins())
 204     return NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA;
 205
 206   // refresh the component registry first, see bug 87913
 207   nsCOMPtr<nsIServiceManager> servManager;
 208   NS_GetServiceManager(getter_AddRefs(servManager));
 209   nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servManager);
 210   if (registrar)
 211     registrar->AutoRegister(nsnull);
 212
 213   if (!mPluginHost) {
 214     mPluginHost = do_GetService(kPluginManagerCID, &res);
 215   }
 216
 217   if(NS_FAILED(res)) {
 218     return res;
 219   }
 220
 221   nsCOMPtr<nsIPluginManager> pm(do_QueryInterface(mPluginHost));
 222
 223   // NS_ERROR_PLUGINS_PLUGINSNOTCHANGED on reloading plugins indicates
 224   // that plugins did not change and was not reloaded
 225   PRBool pluginsNotChanged = PR_FALSE;
 226   if(pm)
 227     pluginsNotChanged = (NS_ERROR_PLUGINS_PLUGINSNOTCHANGED == pm->ReloadPlugins(aReloadDocuments));
 228
 229   // no need to reload the page if plugins have not been changed
 230   // in fact, if we do reload we can hit recursive load problem, see bug 93351
 231   if(pluginsNotChanged)
 232     return res;
 233
 234   nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(mDocShell);
 235
 236   if (mPluginArray != nsnull) {
 237     for (PRUint32 i = 0; i < mPluginCount; i++)
 238       NS_IF_RELEASE(mPluginArray[i]);
 239
 240     delete[] mPluginArray;
 241   }
 242
 243   mPluginCount = 0;
 244   mPluginArray = nsnull;
 245
 246   if (mNavigator)
 247     mNavigator->RefreshMIMEArray();
 248
 249   if (aReloadDocuments && webNav)
 250     webNav->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
 251
 252   return res;
 253 }
 254
 255 nsresult
 256 nsPluginArray::GetPlugins()
 257 {
 258   nsresult rv = GetLength(&mPluginCount);
 259   if (NS_SUCCEEDED(rv)) {
 260     mPluginArray = new nsIDOMPlugin*[mPluginCount];
 261     if (!mPluginArray)
 262       return NS_ERROR_OUT_OF_MEMORY;
 263
 264     if (!mPluginCount)
 265       return NS_OK;
 266
 267     rv = mPluginHost->GetPlugins(mPluginCount, mPluginArray);
 268     if (NS_SUCCEEDED(rv)) {
 269       // need to wrap each of these with a nsPluginElement, which
 270       // is scriptable.
 271       for (PRUint32 i = 0; i < mPluginCount; i++) {
 272         nsIDOMPlugin* wrapper = new nsPluginElement(mPluginArray[i]);
 273         NS_IF_ADDREF(wrapper);
 274         mPluginArray[i] = wrapper;
 275       }
 276     } else {
 277       /* XXX this code is all broken. If GetPlugins fails, there's no contract
 278        *     explaining what should happen. Instead of deleting elements in an
 279        *     array of random pointers, we mark the array as 0 length.
 280        */
 281       mPluginCount = 0;
 282     }
 283   }
 284   return rv;
 285 }
 286
 287 //
 288
 289 nsPluginElement::nsPluginElement(nsIDOMPlugin* plugin)
 290 {
 291   mPlugin = plugin;  // don't AddRef, see nsPluginArray::Item.
 292   mMimeTypeCount = 0;
 293   mMimeTypeArray = nsnull;
 294 }
 295
 296 nsPluginElement::~nsPluginElement()
 297 {
 298   NS_IF_RELEASE(mPlugin);
 299
 300   if (mMimeTypeArray != nsnull) {
 301     for (PRUint32 i = 0; i < mMimeTypeCount; i++)
 302       NS_IF_RELEASE(mMimeTypeArray[i]);
 303     delete[] mMimeTypeArray;
 304   }
 305 }
 306
 307
 308 // QueryInterface implementation for nsPluginElement
 309 NS_INTERFACE_MAP_BEGIN(nsPluginElement)
 310   NS_INTERFACE_MAP_ENTRY(nsISupports)
 311   NS_INTERFACE_MAP_ENTRY(nsIDOMPlugin)
 312   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Plugin)
 313 NS_INTERFACE_MAP_END
 314
 315
 316 NS_IMPL_ADDREF(nsPluginElement)
 317 NS_IMPL_RELEASE(nsPluginElement)
 318
 319
 320 NS_IMETHODIMP
 321 nsPluginElement::GetDescription(nsAString& aDescription)
 322 {
 323   return mPlugin->GetDescription(aDescription);
 324 }
 325
 326 NS_IMETHODIMP
 327 nsPluginElement::GetFilename(nsAString& aFilename)
 328 {
 329   return mPlugin->GetFilename(aFilename);
 330 }
 331
 332 NS_IMETHODIMP
 333 nsPluginElement::GetName(nsAString& aName)
 334 {
 335   return mPlugin->GetName(aName);
 336 }
 337
 338 NS_IMETHODIMP
 339 nsPluginElement::GetLength(PRUint32* aLength)
 340 {
 341   return mPlugin->GetLength(aLength);
 342 }
 343
 344 nsIDOMMimeType*
 345 nsPluginElement::GetItemAt(PRUint32 aIndex, nsresult *aResult)
 346 {
 347   if (mMimeTypeArray == nsnull) {
 348     *aResult = GetMimeTypes();
 349     if (*aResult != NS_OK)
 350       return nsnull;
 351   }
 352
 353   if (aIndex >= mMimeTypeCount) {
 354     *aResult = NS_ERROR_FAILURE;
 355
 356     return nsnull;
 357   }
 358
 359   *aResult = NS_OK;
 360
 361   return mMimeTypeArray[aIndex];
 362 }
 363
 364 NS_IMETHODIMP
 365 nsPluginElement::Item(PRUint32 aIndex, nsIDOMMimeType** aReturn)
 366 {
 367   nsresult rv;
 368
 369   NS_IF_ADDREF(*aReturn = GetItemAt(aIndex, &rv));
 370
 371   return rv;
 372 }
 373
 374 nsIDOMMimeType*
 375 nsPluginElement::GetNamedItem(const nsAString& aName, nsresult *aResult)
 376 {
 377   if (mMimeTypeArray == nsnull) {
 378     *aResult = GetMimeTypes();
 379     if (*aResult != NS_OK)
 380       return nsnull;
 381   }
 382
 383   *aResult = NS_OK;
 384   for (PRUint32 i = 0; i < mMimeTypeCount; i++) {
 385     nsAutoString type;
 386     nsIDOMMimeType* mimeType = mMimeTypeArray[i];
 387     if (mimeType->GetType(type) == NS_OK && type.Equals(aName)) {
 388       return mimeType;
 389     }
 390   }
 391
 392   return nsnull;
 393 }
 394
 395 NS_IMETHODIMP
 396 nsPluginElement::NamedItem(const nsAString& aName, nsIDOMMimeType** aReturn)
 397 {
 398   nsresult rv;
 399
 400   NS_IF_ADDREF(*aReturn = GetNamedItem(aName, &rv));
 401
 402   return rv;
 403 }
 404
 405 nsresult
 406 nsPluginElement::GetMimeTypes()
 407 {
 408   nsresult rv = mPlugin->GetLength(&mMimeTypeCount);
 409   if (rv == NS_OK) {
 410     mMimeTypeArray = new nsIDOMMimeType*[mMimeTypeCount];
 411     if (mMimeTypeArray == nsnull)
 412       return NS_ERROR_OUT_OF_MEMORY;
 413     for (PRUint32 i = 0; i < mMimeTypeCount; i++) {
 414       nsCOMPtr<nsIDOMMimeType> mimeType;
 415       rv = mPlugin->Item(i, getter_AddRefs(mimeType));
 416       if (rv != NS_OK)
 417         break;
 418       mimeType = new nsMimeType(this, mimeType);
 419       NS_IF_ADDREF(mMimeTypeArray[i] = mimeType);
 420     }
 421   }
 422   return rv;
 423 }