Finish moving plugin probing out of process.

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"
@@ skipping 49 matching lines @@
   std::vector<webkit::npapi::PluginGroup> groups;
   webkit::npapi::PluginList::Singleton()->GetPluginGroups(false, &groups);
   callback.Run(groups);
 }
 
 // Callback set on the PluginList to assert that plugin loading happens on the
 // correct thread.
 void WillLoadPluginsCallback() {
   // TODO(rsesek): Change these to CHECKs.
 #if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_MACOSX))
-  LOG_IF(ERROR, !BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 #else
-  LOG(ERROR) << "Plugin loading should happen out-of-process.";
+  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.
@@ skipping 234 matching lines @@
 
 PluginProcessHost* PluginService::FindOrStartNpapiPluginProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   webkit::WebPluginInfo info;
-  if (!webkit::npapi::PluginList::Singleton()->GetPluginInfoByPath(
-          plugin_path, &info)) {
+  if (!GetPluginInfoByPath(plugin_path, &info)) {
     return NULL;
   }
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost());
   if (!new_host->Init(info, ui_locale_)) {
     NOTREACHED();  // Init is not expected to fail.
     return NULL;
   }
   return new_host.release();
@@ skipping 41 matching lines @@
 
 void PluginService::OpenChannelToNpapiPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   DCHECK(!ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.insert(client);
-  // The PluginList::GetPluginInfo may need to load the plugins.  Don't do it on
-  // the IO thread.
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(
-          this, &PluginService::GetAllowedPluginForOpenChannelToPlugin,
-          render_process_id, render_view_id, url, page_url, mime_type,
-          client, &client->GetResourceContext()));
+
+  // Make sure plugins are loaded if necessary.
+  content::PluginServiceFilterParams params = {
+    render_process_id,
+    render_view_id,
+    page_url,
+    &client->GetResourceContext()
+  };
+  GetPlugins(
+      base::Bind(&PluginService::ForwardGetAllowedPluginForOpenChannelToPlugin,
+                 base::Unretained(this), params, url, mime_type, client));
 }
 
 void PluginService::OpenChannelToPpapiPlugin(
     const FilePath& path,
     PpapiPluginProcessHost::PluginClient* client) {
   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess(
       path, client);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else  // Send error.
@@ skipping 10 matching lines @@
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
 void PluginService::CancelOpenChannelToNpapiPlugin(
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.erase(client);
 }
 
+void PluginService::ForwardGetAllowedPluginForOpenChannelToPlugin(
+    const content::PluginServiceFilterParams& params,
+    const GURL& url,
+    const std::string& mime_type,
+    PluginProcessHost::Client* client,
+    const std::vector<webkit::WebPluginInfo>&) {
+  GetAllowedPluginForOpenChannelToPlugin(params.render_process_id,
+      params.render_view_id, url, params.page_url, mime_type, client,
+      params.resource_context);
+}
+
 void PluginService::GetAllowedPluginForOpenChannelToPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     const content::ResourceContext* resource_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(resource_context);
   webkit::WebPluginInfo info;
   bool allow_wildcard = true;
   bool found = GetPluginInfo(
       render_process_id, render_view_id, *resource_context,
       url, page_url, mime_type, allow_wildcard,
       NULL, &info, NULL);
   FilePath plugin_path;
   if (found)
     plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(
-          this, &PluginService::FinishOpenChannelToPlugin,
-          plugin_path, client));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&PluginService::FinishOpenChannelToPlugin,
+                 base::Unretained(this), plugin_path, client));
 }
 
 void PluginService::FinishOpenChannelToPlugin(
     const FilePath& plugin_path,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Make sure it hasn't been canceled yet.
   if (!ContainsKey(pending_plugin_clients_, client))
     return;
@@ skipping 20 matching lines @@
   return use_stale;
 }
 
 bool PluginService::GetPluginInfo(int render_process_id,
                                   int render_view_id,
                                   const content::ResourceContext& context,
                                   const GURL& url,
                                   const GURL& page_url,
                                   const std::string& mime_type,
                                   bool allow_wildcard,
-                                  bool* use_stale,
+                                  bool* is_stale,
                                   webkit::WebPluginInfo* info,
                                   std::string* actual_mime_type) {
-  webkit::npapi::PluginList* plugin_list =
-      webkit::npapi::PluginList::Singleton();
-  // GetPluginInfoArray may need to load the plugins, so we need to be
-  // on the FILE thread.
-  DCHECK(use_stale || BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<webkit::WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
-  plugin_list->GetPluginInfoArray(
-      url, mime_type, allow_wildcard, use_stale, &plugins, &mime_types);
+  bool stale = GetPluginInfoArray(
+      url, mime_type, allow_wildcard, &plugins, &mime_types);
+  if (is_stale)
+    *is_stale = stale;
   if (plugins.size() > 1 &&
       plugins.back().path ==
           FilePath(webkit::npapi::kDefaultPluginLibraryName)) {
     // If there is at least one plug-in handling the required MIME type (apart
     // from the default plug-in), we don't need the default plug-in.
     plugins.pop_back();
   }
 
   for (size_t i = 0; i < plugins.size(); ++i) {
     if (!filter_ || filter_->ShouldUsePlugin(render_process_id,
                                              render_view_id,
                                              &context,
                                              url,
                                              page_url,
                                              &plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
+bool PluginService::GetPluginInfoByPath(const FilePath& plugin_path,
+                                        webkit::WebPluginInfo* info) {
+  std::vector<webkit::WebPluginInfo> plugins;
+  webkit::npapi::PluginList::Singleton()->GetPluginsIfNoRefreshNeeded(
+      &plugins);
+
+  for (std::vector<webkit::WebPluginInfo>::iterator it = plugins.begin();
+       it != plugins.end();
+       ++it) {
+    if (it->path == plugin_path) {
+      *info = *it;
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void PluginService::RefreshPluginList() {
   webkit::npapi::PluginList::Singleton()->RefreshPlugins();
 }
 
 void PluginService::GetPlugins(const GetPluginsCallback& callback) {
   scoped_refptr<base::MessageLoopProxy> target_loop(
       MessageLoop::current()->message_loop_proxy());
 
 #if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_MACOSX))
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
@@ skipping 87 matching lines @@
     }
   }
   if (info)
     return info;
   // We did not find the plugin in our list. But wait! the plugin can also
   // be a latecomer, as it happens with pepper flash. This information
   // can be obtained from the PluginList singleton and we can use it to
   // construct it and add it to the list. This same deal needs to be done
   // in the renderer side in PepperPluginRegistry.
   webkit::WebPluginInfo webplugin_info;
-  if (!webkit::npapi::PluginList::Singleton()->GetPluginInfoByPath(
-      plugin_path, &webplugin_info))
+  if (!GetPluginInfoByPath(plugin_path, &webplugin_info))
     return NULL;
   PepperPluginInfo new_pepper_info;
   if (!MakePepperPluginInfo(webplugin_info, &new_pepper_info))
     return NULL;
   ppapi_plugins_.push_back(new_pepper_info);
   return &ppapi_plugins_[ppapi_plugins_.size() - 1];
 }
 
 #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