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);
+  // Checks if the plug-in state can be enabled or disabled according to
+  // |enable| or if the plug-in state cannot be changed because of a policy.
+  void CanEnablePlugin(bool enable, const FilePath& file_path,

[Bernhard Bauer, 2012/08/24 08:15:34]

I think we could combine these methods. There are no callers who only want to
check whether a plug-in can be enabled/disabled; if it can be, then they always
want to do it. So we could modify EnablePlugin below to take a void(bool)
callback and pass in the result.

[ibraaaa, 2012/08/24 15:51:29]

I wanted to leave this in another CL with modifying calls to no use PluginGroup.
However, since we will hold to resolve the IsPluginEnabled CL then I fixed it
and added support for 
not using PlugingGroup in this class and its dependencies.

On 2012/08/24 08:15:34, Bernhard Bauer wrote:

+                       const base::Callback<void(bool)>& cb);
 
   // 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.
   void EnablePlugin(bool enable, const FilePath& file_path,
                     const base::Closure& callback);
 
   // Enables or disables a plug-in in all profiles, and calls |callback|
   // afterwards. This sets a default for profiles which are created later as
@@ skipping 62 matching lines @@
   // 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 'CanEnablePlugin' method.
+  // It performs the actual logic to check if a plug-in can be enabled.
+  void CanEnablePluginCallback(bool enabled, const FilePath& path,
+                               const base::Callback<void(bool)>& cb,
+                               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_