content/child/npapi/plugin_lib.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/npapi/plugin_lib.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/metrics/stats_counters.h"
  11 #include "base/strings/string_util.h"
  12 #include "content/child/npapi/plugin_host.h"
  13 #include "content/child/npapi/plugin_instance.h"
  14 #include "content/common/plugin_list.h"
  15
  16 namespace content {
  17
  18 const char kPluginLibrariesLoadedCounter[] = "PluginLibrariesLoaded";
  19 const char kPluginInstancesActiveCounter[] = "PluginInstancesActive";
  20
  21 // A list of all the instantiated plugins.
  22 static std::vector<scoped_refptr<PluginLib> >* g_loaded_libs;
  23
  24 PluginLib* PluginLib::CreatePluginLib(const base::FilePath& filename) {
  25   // We can only have one PluginLib object per plugin as it controls the per
  26   // instance function calls (i.e. NP_Initialize and NP_Shutdown).  So we keep
  27   // a map of PluginLib objects.
  28   if (!g_loaded_libs)
  29     g_loaded_libs = new std::vector<scoped_refptr<PluginLib> >;
  30
  31   for (size_t i = 0; i < g_loaded_libs->size(); ++i) {
  32     if ((*g_loaded_libs)[i]->plugin_info().path == filename)
  33       return (*g_loaded_libs)[i].get();
  34   }
  35
  36   WebPluginInfo info;
  37   if (!PluginList::Singleton()->ReadPluginInfo(filename, &info))
  38     return NULL;
  39
  40   return new PluginLib(info);
  41 }
  42
  43 void PluginLib::UnloadAllPlugins() {
  44   if (g_loaded_libs) {
  45     // PluginLib::Unload() can remove items from the list and even delete
  46     // the list when it removes the last item, so we must work with a copy
  47     // of the list so that we don't get the carpet removed under our feet.
  48     std::vector<scoped_refptr<PluginLib> > loaded_libs(*g_loaded_libs);
  49     for (size_t i = 0; i < loaded_libs.size(); ++i)
  50       loaded_libs[i]->Unload();
  51
  52     if (g_loaded_libs && g_loaded_libs->empty()) {
  53       delete g_loaded_libs;
  54       g_loaded_libs = NULL;
  55     }
  56   }
  57 }
  58
  59 void PluginLib::ShutdownAllPlugins() {
  60   if (g_loaded_libs) {
  61     for (size_t i = 0; i < g_loaded_libs->size(); ++i)
  62       (*g_loaded_libs)[i]->Shutdown();
  63   }
  64 }
  65
  66 PluginLib::PluginLib(const WebPluginInfo& info)
  67     : web_plugin_info_(info),
  68       library_(NULL),
  69       initialized_(false),
  70       saved_data_(0),
  71       instance_count_(0),
  72       skip_unload_(false),
  73       defer_unload_(false) {
  74   base::StatsCounter(kPluginLibrariesLoadedCounter).Increment();
  75   memset(static_cast<void*>(&plugin_funcs_), 0, sizeof(plugin_funcs_));
  76   g_loaded_libs->push_back(make_scoped_refptr(this));
  77
  78   memset(&entry_points_, 0, sizeof(entry_points_));
  79 }
  80
  81 PluginLib::~PluginLib() {
  82   base::StatsCounter(kPluginLibrariesLoadedCounter).Decrement();
  83   if (saved_data_ != 0) {
  84     // TODO - delete the savedData object here
  85   }
  86 }
  87
  88 NPPluginFuncs* PluginLib::functions() {
  89   return &plugin_funcs_;
  90 }
  91
  92 NPError PluginLib::NP_Initialize() {
  93   LOG_IF(ERROR, PluginList::DebugPluginLoading())
  94       << "PluginLib::NP_Initialize(" << web_plugin_info_.path.value()
  95       << "): initialized=" << initialized_;
  96   if (initialized_)
  97     return NPERR_NO_ERROR;
  98
  99   if (!Load())
 100     return NPERR_MODULE_LOAD_FAILED_ERROR;
 101
 102   PluginHost* host = PluginHost::Singleton();
 103   if (host == 0)
 104     return NPERR_GENERIC_ERROR;
 105
 106 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 107   NPError rv = entry_points_.np_initialize(host->host_functions(),
 108                                            &plugin_funcs_);
 109 #else
 110   NPError rv = entry_points_.np_initialize(host->host_functions());
 111 #if defined(OS_MACOSX)
 112   // On the Mac, we need to get entry points after calling np_initialize to
 113   // match the behavior of other browsers.
 114   if (rv == NPERR_NO_ERROR) {
 115     rv = entry_points_.np_getentrypoints(&plugin_funcs_);
 116   }
 117 #endif  // OS_MACOSX
 118 #endif
 119   LOG_IF(ERROR, PluginList::DebugPluginLoading())
 120       << "PluginLib::NP_Initialize(" << web_plugin_info_.path.value()
 121       << "): result=" << rv;
 122   initialized_ = (rv == NPERR_NO_ERROR);
 123   return rv;
 124 }
 125
 126 void PluginLib::NP_Shutdown(void) {
 127   DCHECK(initialized_);
 128   entry_points_.np_shutdown();
 129 }
 130
 131 NPError PluginLib::NP_ClearSiteData(const char* site,
 132                                     uint64 flags,
 133                                     uint64 max_age) {
 134   DCHECK(initialized_);
 135   if (plugin_funcs_.clearsitedata)
 136     return plugin_funcs_.clearsitedata(site, flags, max_age);
 137   return NPERR_INVALID_FUNCTABLE_ERROR;
 138 }
 139
 140 char** PluginLib::NP_GetSitesWithData() {
 141   DCHECK(initialized_);
 142   if (plugin_funcs_.getsiteswithdata)
 143     return plugin_funcs_.getsiteswithdata();
 144   return NULL;
 145 }
 146
 147 void PluginLib::PreventLibraryUnload() {
 148   skip_unload_ = true;
 149 }
 150
 151 PluginInstance* PluginLib::CreateInstance(const std::string& mime_type) {
 152   PluginInstance* new_instance = new PluginInstance(this, mime_type);
 153   instance_count_++;
 154   base::StatsCounter(kPluginInstancesActiveCounter).Increment();
 155   DCHECK_NE(static_cast<PluginInstance*>(NULL), new_instance);
 156   return new_instance;
 157 }
 158
 159 void PluginLib::CloseInstance() {
 160   base::StatsCounter(kPluginInstancesActiveCounter).Decrement();
 161   instance_count_--;
 162   // If a plugin is running in its own process it will get unloaded on process
 163   // shutdown.
 164   if ((instance_count_ == 0) && !defer_unload_)
 165     Unload();
 166 }
 167
 168 bool PluginLib::Load() {
 169   if (library_)
 170     return true;
 171
 172   bool rv = false;
 173   base::NativeLibrary library = 0;
 174   base::NativeLibraryLoadError error;
 175
 176 #if defined(OS_WIN)
 177   // This is to work around a bug in the Real player recorder plugin which
 178   // intercepts LoadLibrary calls from chrome.dll and wraps NPAPI functions
 179   // provided by the plugin. It crashes if the media player plugin is being
 180   // loaded. Workaround is to load the dll dynamically by getting the
 181   // LoadLibrary API address from kernel32.dll which bypasses the recorder
 182   // plugin.
 183   if (web_plugin_info_.name.find(L"Windows Media Player") !=
 184       std::wstring::npos) {
 185     library = base::LoadNativeLibraryDynamically(web_plugin_info_.path);
 186   } else {
 187     library = base::LoadNativeLibrary(web_plugin_info_.path, &error);
 188   }
 189 #else
 190   library = base::LoadNativeLibrary(web_plugin_info_.path, &error);
 191 #endif
 192
 193   if (!library) {
 194     LOG_IF(ERROR, PluginList::DebugPluginLoading())
 195         << "Couldn't load plugin " << web_plugin_info_.path.value() << " "
 196         << error.ToString();
 197     return rv;
 198   }
 199
 200 #if defined(OS_MACOSX)
 201   // According to the WebKit source, QuickTime at least requires us to call
 202   // UseResFile on the plugin resources before loading.
 203   if (library->bundle_resource_ref != -1)
 204     UseResFile(library->bundle_resource_ref);
 205 #endif
 206
 207   rv = true;  // assume success now
 208
 209   entry_points_.np_initialize =
 210       (NP_InitializeFunc)base::GetFunctionPointerFromNativeLibrary(library,
 211           "NP_Initialize");
 212   if (entry_points_.np_initialize == 0)
 213     rv = false;
 214
 215 #if defined(OS_WIN) || defined(OS_MACOSX)
 216   entry_points_.np_getentrypoints =
 217       (NP_GetEntryPointsFunc)base::GetFunctionPointerFromNativeLibrary(
 218           library, "NP_GetEntryPoints");
 219   if (entry_points_.np_getentrypoints == 0)
 220     rv = false;
 221 #endif
 222
 223   entry_points_.np_shutdown =
 224       (NP_ShutdownFunc)base::GetFunctionPointerFromNativeLibrary(library,
 225           "NP_Shutdown");
 226   if (entry_points_.np_shutdown == 0)
 227     rv = false;
 228
 229   if (rv) {
 230     plugin_funcs_.size = sizeof(plugin_funcs_);
 231     plugin_funcs_.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
 232 #if !defined(OS_POSIX)
 233     if (entry_points_.np_getentrypoints(&plugin_funcs_) != NPERR_NO_ERROR)
 234       rv = false;
 235 #else
 236     // On Linux and Mac, we get the plugin entry points during NP_Initialize.
 237 #endif
 238   }
 239
 240   if (rv) {
 241     LOG_IF(ERROR, PluginList::DebugPluginLoading())
 242         << "Plugin " << web_plugin_info_.path.value()
 243         << " loaded successfully.";
 244     library_ = library;
 245   } else {
 246     LOG_IF(ERROR, PluginList::DebugPluginLoading())
 247         << "Plugin " << web_plugin_info_.path.value()
 248         << " failed to load, unloading.";
 249     base::UnloadNativeLibrary(library);
 250   }
 251
 252   return rv;
 253 }
 254
 255 // This is a helper to help perform a delayed NP_Shutdown and FreeLibrary on the
 256 // plugin dll.
 257 void FreePluginLibraryHelper(const base::FilePath& path,
 258                              base::NativeLibrary library,
 259                              NP_ShutdownFunc shutdown_func) {
 260   if (shutdown_func) {
 261     // Don't call NP_Shutdown if the library has been reloaded since this task
 262     // was posted.
 263     bool reloaded = false;
 264     if (g_loaded_libs) {
 265       for (size_t i = 0; i < g_loaded_libs->size(); ++i) {
 266         if ((*g_loaded_libs)[i]->plugin_info().path == path) {
 267           reloaded = true;
 268           break;
 269         }
 270       }
 271     }
 272     if (!reloaded)
 273       shutdown_func();
 274   }
 275
 276   if (library) {
 277     // Always call base::UnloadNativeLibrary so that the system reference
 278     // count is decremented.
 279     base::UnloadNativeLibrary(library);
 280   }
 281 }
 282
 283 void PluginLib::Unload() {
 284   if (library_) {
 285     // In case of single process mode, a plugin can delete itself
 286     // by executing a script. So delay the unloading of the library
 287     // so that the plugin will have a chance to unwind.
 288 /* TODO(dglazkov): Revisit when re-enabling the JSC build.
 289 #if USE(JSC)
 290     // The plugin NPAPI instances may still be around. Delay the
 291     // NP_Shutdown and FreeLibrary calls at least till the next
 292     // peek message.
 293     defer_unload = true;
 294 #endif
 295 */
 296     if (!defer_unload_) {
 297       LOG_IF(ERROR, PluginList::DebugPluginLoading())
 298           << "Scheduling delayed unload for plugin "
 299           << web_plugin_info_.path.value();
 300       base::MessageLoop::current()->PostTask(
 301           FROM_HERE,
 302           base::Bind(&FreePluginLibraryHelper,
 303                      web_plugin_info_.path,
 304                      skip_unload_ ? NULL : library_,
 305                      entry_points_.np_shutdown));
 306     } else {
 307       Shutdown();
 308       if (!skip_unload_) {
 309         LOG_IF(ERROR, PluginList::DebugPluginLoading())
 310             << "Unloading plugin " << web_plugin_info_.path.value();
 311         base::UnloadNativeLibrary(library_);
 312       }
 313     }
 314
 315     library_ = NULL;
 316   }
 317
 318   for (size_t i = 0; i < g_loaded_libs->size(); ++i) {
 319     if ((*g_loaded_libs)[i].get() == this) {
 320       g_loaded_libs->erase(g_loaded_libs->begin() + i);
 321       break;
 322     }
 323   }
 324   if (g_loaded_libs->empty()) {
 325     delete g_loaded_libs;
 326     g_loaded_libs = NULL;
 327   }
 328 }
 329
 330 void PluginLib::Shutdown() {
 331   if (initialized_) {
 332     NP_Shutdown();
 333     initialized_ = false;
 334   }
 335 }
 336
 337 }  // namespace content