Queue callbacks in PluginService::GetPlugins.

content/browser/plugin_service.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 "content/browser/plugin_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/plugin_service_filter.h"
 #include "content/browser/ppapi_plugin_process_host.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/resource_context.h"
-#include "content/browser/utility_process_host.h"
 #include "content/common/content_notification_types.h"
 #include "content/common/content_switches.h"
 #include "content/common/notification_service.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/plugin_messages.h"
-#include "content/common/utility_messages.h"
 #include "content/common/view_messages.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/webplugininfo.h"
 
+#if defined(OS_POSIX)
+#include "content/browser/plugin_loader.h"
+#endif
+
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 using ::base::files::FilePathWatcher;
 #endif
 
 using content::PluginServiceFilter;
 
 namespace {
 
 // Helper function that merely runs the callback with the result. Called on the
 // thread on which the original GetPlugins() call was made.
@@ skipping 17 matching lines @@
 // correct thread.
 void WillLoadPluginsCallback() {
   // TODO(rsesek): Change these to CHECKs.
 #if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_MACOSX))
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 #else
   CHECK(false) << "Plugin loading should happen out-of-process.";
 #endif
 }
 
-#if defined(OS_POSIX)
-// Utility child process client that manages the IPC for loading plugins out of
-// process.
-class PluginLoaderClient : public UtilityProcessHost::Client {
- public:
-  // Meant to be called on the IO thread. Will invoke the callback on the target
-  // loop when the plugins have been loaded.
-  static void LoadPluginsOutOfProcess(
-      base::MessageLoopProxy* target_loop,
-      const PluginService::GetPluginsCallback& callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-    PluginLoaderClient* client = new PluginLoaderClient(target_loop, callback);
-    UtilityProcessHost* process_host =
-        new UtilityProcessHost(client, BrowserThread::IO);
-    process_host->set_no_sandbox(true);
-#if defined(OS_MACOSX)
-    process_host->set_child_flags(ChildProcessHost::CHILD_ALLOW_HEAP_EXECUTION);
-#endif
-
-    std::vector<FilePath> extra_plugin_paths;
-    std::vector<FilePath> extra_plugin_dirs;
-    std::vector<webkit::WebPluginInfo> internal_plugins;
-    webkit::npapi::PluginList::Singleton()->GetPluginPathListsToLoad(
-        &extra_plugin_paths, &extra_plugin_dirs, &internal_plugins);
-
-    process_host->Send(new UtilityMsg_LoadPlugins(
-        extra_plugin_paths, extra_plugin_dirs, internal_plugins));
-  }
-
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(PluginLoaderClient, message)
-      IPC_MESSAGE_HANDLER(UtilityHostMsg_LoadedPlugins, OnGotPlugins)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-  }
-
-  virtual void OnProcessCrashed(int exit_code) OVERRIDE {
-    LOG(ERROR) << "Out-of-process plugin loader crashed with code " << exit_code
-               << ". You will have no plugins!";
-    // Don't leave callers hanging.
-    OnGotPlugins(std::vector<webkit::WebPluginInfo>());
-  }
-
-  virtual void OnGotPlugins(const std::vector<webkit::WebPluginInfo>& plugins) {
-    webkit::npapi::PluginList::Singleton()->SetPlugins(plugins);
-    target_loop_->PostTask(FROM_HERE,
-        base::Bind(&RunGetPluginsCallback, callback_, plugins));
-  }
-
- private:
-  PluginLoaderClient(base::MessageLoopProxy* target_loop,
-                     const PluginService::GetPluginsCallback& callback)
-      : target_loop_(target_loop),
-        callback_(callback) {
-  }
-
-  scoped_refptr<base::MessageLoopProxy> target_loop_;
-  PluginService::GetPluginsCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(PluginLoaderClient);
-};
-#endif  // OS_POSIX
-
 }  // namespace
 
 #if defined(OS_MACOSX)
 static void NotifyPluginsOfActivation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     plugin->OnAppActivation();
@@ skipping 415 matching lines @@
           target_loop, callback));
 #else
   std::vector<webkit::WebPluginInfo> cached_plugins;
   if (webkit::npapi::PluginList::Singleton()->GetPluginsIfNoRefreshNeeded(
           &cached_plugins)) {
     // Can't assume the caller is reentrant.
     target_loop->PostTask(FROM_HERE,
         base::Bind(&RunGetPluginsCallback, callback, cached_plugins));
   } else {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&PluginLoaderClient::LoadPluginsOutOfProcess,
-            target_loop, callback));
+        base::Bind(&PluginService::LoadPluginsOutOfProcess,
+                   base::Unretained(this), target_loop, callback));
   }
 #endif
 }
 
 void PluginService::GetPluginGroups(const GetPluginGroupsCallback& callback) {
   GetPlugins(base::Bind(&GetPluginsForGroupsCallback, callback));
 }
 
 void PluginService::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<webkit::WebPluginInfo> plugins;
   webkit::npapi::PluginList::Singleton()->GetPlugins(&plugins);
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(&RunGetPluginsCallback, callback, plugins));
 }
 
+#if defined(OS_POSIX)
+void PluginService::LoadPluginsOutOfProcess(
+    base::MessageLoopProxy* target_loop,
+    const PluginService::GetPluginsCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!plugin_loader_)
+    plugin_loader_ = new PluginLoader();
+  plugin_loader_->LoadPlugins(target_loop, callback);
+}
+#endif
+
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
   webkit::npapi::PluginList::Singleton()->RefreshPlugins();
@@ skipping 67 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif