Changing PluginPrefs to use PluginFinder's async interface.

chrome/browser/plugin_prefs.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROME_BROWSER_PLUGIN_PREFS_H_
 #define CHROME_BROWSER_PLUGIN_PREFS_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/api/prefs/pref_change_registrar.h"
+#include "chrome/browser/plugin_finder.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/refcounted_profile_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 
 class Profile;
 
 namespace base {
 class ListValue;
 }
 
@@ skipping 32 matching lines @@
   PluginPrefs();
 
   // Associates this instance with |prefs|. This enables or disables
   // plugin groups as defined by the user's preferences.
   // This method should only be called on the UI thread.
   void SetPrefs(PrefService* prefs);
 
   // Enable or disable a plugin group.
   void EnablePluginGroup(bool enable, const string16& group_name);
 
-  // Returns true if the plug-in state can be enabled or disabled according to
-  // |enable|, false if the plug-in state cannot be changed because of a policy.
-  bool CanEnablePlugin(bool enable, const FilePath& file_path);
-
-  // Enables or disables a specific plugin file, and calls |callback|
-  // afterwards.
-  // If the plug-in state cannot be changed because of a policy (as indicated
-  // by |CanEnablePlugin|), it will be silently ignored.
+  // Enables or disables a specific plugin file, if possible,
+  // and calls |enableCallback| afterwards. If not possible (because the
+  // plug-in state cannot be changed because of a policy), it will silently

[Pam (message me for reviews), 2012/08/27 13:18:05]

nit: clarify "it": something like "this entire method will silently be ignored,
and no callbacks will be called"

[ibraaaa, 2012/08/28 09:25:52]

Done.

+  // be ignored. |canEnabledCallback| will be called after the plug-in

[Pam (message me for reviews), 2012/08/27 13:18:05]

typo: |canEnableCallback|

[ibraaaa, 2012/08/28 09:25:52]

Done.

+  // change state check is called.

[Pam (message me for reviews), 2012/08/27 13:18:05]

I don't understand what a "plug-in change state check" is. Do you mean a
"plug-in state-change check"? Or equivalently, "the method to check that the
plug-in state can be changed"?

[ibraaaa, 2012/08/28 09:25:52]

Done.

   void EnablePlugin(bool enable, const FilePath& file_path,
-                    const base::Closure& callback);
+                    const base::Closure& enableCallback,
+                    const base::Callback<void(bool)>& canEnableCallback);
 
   // Enables or disables a plug-in in all profiles, and calls |callback|
   // afterwards. This sets a default for profiles which are created later as
   // well.
   // If the plug-in state in a profile cannot be changed because of a policy,
   // it will be silently ignored.
   // This method should only be called on the UI thread.
   static void EnablePluginGlobally(bool enable, const FilePath& file_path,
                                    const base::Closure& callback);
 
@@ skipping 30 matching lines @@
       const std::set<string16>& disabled_exception_patterns,
       const std::set<string16>& enabled_patterns);
 
   // Returns the plugin list to use, either the singleton or the override.
   webkit::npapi::PluginList* GetPluginList() const;
 
   // Callback for after the plugin groups have been loaded.
   void EnablePluginGroupInternal(
       bool enabled,
       const string16& group_name,
-      const std::vector<webkit::npapi::PluginGroup>& groups);
+      PluginFinder* plugin_finder,
+      const std::vector<webkit::WebPluginInfo>& plugins);
   void EnablePluginInternal(
       bool enabled,
       const FilePath& path,
+      PluginFinder* plugin_finder,
       const base::Closure& callback,
-      const std::vector<webkit::npapi::PluginGroup>& groups);
+      const std::vector<webkit::WebPluginInfo>& plugins);
 
   // Called on the file thread to get the data necessary to update the saved
   // preferences.
   void GetPreferencesDataOnFileThread();
 
   // Called on the UI thread with the plugin data to save the preferences.
-  void OnUpdatePreferences(
-      const std::vector<webkit::npapi::PluginGroup>& groups);
+  void OnUpdatePreferences(const std::vector<webkit::WebPluginInfo>& plugins,
+                           PluginFinder* finder);
 
   // Sends the notification that plugin data has changed.
   void NotifyPluginStatusChanged();
 
   static void ListValueToStringSet(const base::ListValue* src,
                                    std::set<string16>* dest);
 
   // Checks if |name| matches any of the patterns in |pattern_set|.
   static bool IsStringMatchedInSet(const string16& name,
                                    const std::set<string16>& pattern_set);
 
+  // Callback method called by 'EnablePlugin' method.
+  // It performs the logic to check if a plug-in can be enabled.
+  void EnablePluginIfPossibleCallback(
+      bool enabled, const FilePath& path,
+      const base::Closure& enableCallback,
+      const base::Callback<void(bool)>& canEnableCallback,
+      PluginFinder* finder);
+
+  // Callback method that takes in the asynchronously created
+  // plug-in finder instance. It is called by 'EnablePluginGroup'.
+  void GetPluginFinderForEnablePluginGroup(bool enabled,
+                                           const string16& group_name,
+                                           PluginFinder* finder);
+
+  // Callback method that takes in the asynchronously created plug-in finder
+  // instance. It is called by 'GetPreferencesDataOnFileThread'.
+  void GetPluginFinderForGetPreferencesDataOnFileThread(PluginFinder* finder);
+
   // Guards access to the following data structures.
   mutable base::Lock lock_;
 
   std::map<FilePath, bool> plugin_state_;
   std::map<string16, bool> plugin_group_state_;
 
   std::set<string16> policy_disabled_plugin_patterns_;
   std::set<string16> policy_disabled_plugin_exception_patterns_;
   std::set<string16> policy_enabled_plugin_patterns_;
 
   // Weak pointer, owns us. Only used as a notification source.
   Profile* profile_;
 
   // Weak pointer, owned by the profile.
   PrefService* prefs_;
 
   // PluginList to use for testing. If this is NULL, defaults to the global
   // singleton.
   webkit::npapi::PluginList* plugin_list_;
 
   PrefChangeRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginPrefs);
 };
 
 #endif  // CHROME_BROWSER_PLUGIN_PREFS_H_