Finish moving plugin probing out of process.

content/browser/plugin_service.h

 // 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.
 
 // This class responds to requests from renderers for the list of plugins, and
 // also a proxy object for plugin instances.
 
 #ifndef CONTENT_BROWSER_PLUGIN_SERVICE_H_
 #define CONTENT_BROWSER_PLUGIN_SERVICE_H_
 #pragma once
@@ skipping 36 matching lines @@
 class PluginServiceFilter;
 }
 
 namespace webkit {
 namespace npapi {
 class PluginGroup;
 class PluginList;
 }
 }
 
+namespace {
+struct ForwardOpenChannelParams;

[jam, 2011/10/04 22:42:30]

nit: seems a little odd to forward declare stuff in an anonymous namespace. if
you want to forward declare it, usually we put make it a private member

+}
+
 // This must be created on the main thread but it's only called on the IO/file
 // thread. This is an asynchronous wrapper around the PluginList interface for
 // querying plugin information. This must be used instead of that to avoid
 // doing expensive disk operations on the IO/UI threads.
 class CONTENT_EXPORT PluginService
     : public base::WaitableEventWatcher::Delegate,
       public NotificationObserver {
  public:
   struct OverriddenPlugin {
     int render_process_id;
@@ skipping 46 matching lines @@
                                 PluginProcessHost::Client* client);
   void OpenChannelToPpapiPlugin(const FilePath& path,
                                 PpapiPluginProcessHost::PluginClient* client);
   void OpenChannelToPpapiBroker(const FilePath& path,
                                 PpapiPluginProcessHost::BrokerClient* client);
 
   // Cancels opening a channel to a NPAPI plugin.
   void CancelOpenChannelToNpapiPlugin(PluginProcessHost::Client* client);
 
   // Gets the plugin in the list of plugins that matches the given url and mime
-  // type. Must be called on the FILE thread if |use_stale| is NULL.
+  // type. Returns true if the data is frome a stale plugin list, false if it
+  // is up to date. This can be called from any thread.
+  bool GetPluginInfoArray(const GURL& url,
+                          const std::string& mime_type,
+                          bool allow_wildcard,
+                          std::vector<webkit::WebPluginInfo>* info,
+                          std::vector<std::string>* actual_mime_types);
+
+  // Gets plugin info for an individual plugin and filters the plugins using
+  // the |context| and renderer IDs. This will report whether the data is stale
+  // via |is_stale| and returns whether or not the plugin can be found.
   bool 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);
 
+  // Get plugin info by plugin path (including disabled plugins). Returns true
+  // if the plugin is found and WebPluginInfo has been filled in |info|. This
+  // will use cached data in the plugin list.
+  bool GetPluginInfoByPath(const FilePath& plugin_path,
+                           webkit::WebPluginInfo* info);
+
   // Marks the plugin list as dirty and will cause the plugins to be reloaded
   // on the next access through GetPlugins() or GetPluginGroups().
   void RefreshPluginList();
 
   // Asynchronously loads plugins if necessary and then calls back to the
   // provided function on the calling MessageLoop on completion.
   void GetPlugins(const GetPluginsCallback& callback);
 
   // Asynchronously loads the list of plugin groups if necessary and then calls
   // back to the provided function on the calling MessageLoop on completion.
@@ skipping 25 matching lines @@
                        const NotificationDetails& details);
 
   void RegisterPepperPlugins();
 
   PepperPluginInfo* GetRegisteredPpapiPluginInfo(const FilePath& plugin_path);
 
   // Function that is run on the FILE thread to load the plugins synchronously.
   void GetPluginsInternal(base::MessageLoopProxy* target_loop,
                           const GetPluginsCallback& callback);
 
+  // Binding directly to GetAllowedPluginForOpenChannelToPlugin() isn't possible
+  // because more arity is needed <http://crbug.com/98542>. This just forwards.

[Bernhard Bauer, 2011/10/05 13:00:46]

I'm running into the same issue in http://codereview.chromium.org/7990005/.
Could we maybe pull out the parameters that are only passed as context to the
PluginServiceFilter (i.e. render_process_id, render_view_id, page_url,
resource_context) so I can use the same struct?

[Robert Sesek, 2011/10/05 18:27:16]

Done.

+  void ForwardGetAllowedPluginForOpenChannelToPlugin(
+      const ForwardOpenChannelParams& params,
+      const GURL& url,
+      const GURL& page_url,
+      const std::string& mime_type,
+      const std::vector<webkit::WebPluginInfo>&);
   // Helper so we can do the plugin lookup on the FILE thread.
   void 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);
 
@@ skipping 37 matching lines @@
   content::PluginServiceFilter* filter_;
 
   std::set<PluginProcessHost::Client*> pending_plugin_clients_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginService);
 };
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(PluginService);
 
 #endif  // CONTENT_BROWSER_PLUGIN_SERVICE_H_