While initializing the pepper plugin registry in the renderer we load each plugin and attempt to ...

webkit/plugins/ppapi/plugin_module.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/plugins/ppapi/plugin_module.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 404 matching lines @@
                            const FilePath& path,
                            PluginDelegate::ModuleLifetime* lifetime_delegate)
     : lifetime_delegate_(lifetime_delegate),
       callback_tracker_(new CallbackTracker),
       is_crashed_(false),
       broker_(NULL),
       library_(NULL),
       name_(name),
       path_(path),
       reserve_instance_id_(NULL) {
+  memset(&entry_points_, 0, sizeof(entry_points_));
   pp_module_ = ResourceTracker::Get()->AddModule(this);
   GetMainThreadMessageLoop();  // Initialize the main thread message loop.
   GetLivePluginSet()->insert(this);
 }
 
 PluginModule::~PluginModule() {
   // When the module is being deleted, there should be no more instances still
   // holding a reference to us.
   DCHECK(instances_.empty());
 
   GetLivePluginSet()->erase(this);
 
   callback_tracker_->AbortAll();
 
   if (entry_points_.shutdown_module)
     entry_points_.shutdown_module();
 
   if (library_)
     base::UnloadNativeLibrary(library_);
 
   ResourceTracker::Get()->ModuleDeleted(pp_module_);
 
   // When the plugin crashes, we immediately tell the lifetime delegate that
   // we're gone, so we don't want to tell it again.
   if (!is_crashed_)
     lifetime_delegate_->PluginModuleDead(this);
 }
 
 bool PluginModule::InitAsInternalPlugin(const EntryPoints& entry_points) {
-  entry_points_ = entry_points;
-  return InitializeModule();
+  if (InitializeModule(entry_points)) {
+    entry_points_ = entry_points;
+    return true;
+  }
+  return false;
 }
 
 bool PluginModule::InitAsLibrary(const FilePath& path) {
   base::NativeLibrary library = base::LoadNativeLibrary(path, NULL);
   if (!library)
     return false;
 
-  if (!LoadEntryPointsFromLibrary(library, &entry_points_) ||
-      !InitializeModule()) {
+  EntryPoints entry_points;
+
+  if (!LoadEntryPointsFromLibrary(library, &entry_points) ||
+      !InitializeModule(entry_points)) {
     base::UnloadNativeLibrary(library);
     return false;
   }
-
+  entry_points_ = entry_points;
   library_ = library;
   return true;
 }
 
 void PluginModule::InitAsProxied(
     PluginDelegate::OutOfProcessProxy* out_of_process_proxy) {
   DCHECK(!out_of_process_proxy_.get());
   out_of_process_proxy_.reset(out_of_process_proxy);
 }
 
@@ skipping 90 matching lines @@
 PluginDelegate::PpapiBroker* PluginModule::GetBroker(){
   return broker_;
 }
 
 ::ppapi::WebKitForwarding* PluginModule::GetWebKitForwarding() {
   if (!webkit_forwarding_.get())
     webkit_forwarding_.reset(new WebKitForwardingImpl);
   return webkit_forwarding_.get();
 }
 
-bool PluginModule::InitializeModule() {
+bool PluginModule::InitializeModule(const EntryPoints& entry_points) {
   DCHECK(!out_of_process_proxy_.get()) << "Don't call for proxied modules.";
-  int retval = entry_points_.initialize_module(pp_module(), &GetInterface);
+  DCHECK(entry_points.initialize_module != NULL);
+  int retval = entry_points.initialize_module(pp_module(), &GetInterface);
   if (retval != 0) {
     LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit