Make Blacklist::IsBlacklist asynchronous (it will need to be for safe

chrome/browser/extensions/extension_service.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_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 89 matching lines @@
   virtual const ExtensionSet* disabled_extensions() const = 0;
   virtual extensions::PendingExtensionManager* pending_extension_manager() = 0;
 
   // Install an update.  Return true if the install can be started.
   // Set out_crx_installer to the installer if one was started.
   virtual bool UpdateExtension(
       const std::string& id,
       const FilePath& path,
       const GURL& download_url,
       extensions::CrxInstaller** out_crx_installer) = 0;
-  virtual const extensions::Extension* GetExtensionById(const std::string& id,
-                                            bool include_disabled) const = 0;
+  virtual const extensions::Extension* GetExtensionById(
+      const std::string& id,
+      bool include_disabled) const = 0;
   virtual const extensions::Extension* GetInstalledExtension(
       const std::string& id) const = 0;
 
   virtual const extensions::Extension* GetPendingExtensionUpdate(
       const std::string& extension_id) const = 0;
   virtual void FinishDelayedInstallation(const std::string& extension_id) = 0;
 
   virtual bool IsExtensionEnabled(const std::string& extension_id) const = 0;
   virtual bool IsExternalExtensionUninstalled(
       const std::string& extension_id) const = 0;
@@ skipping 82 matching lines @@
                    extensions::Blacklist* blacklist,
                    bool autoupdate_enabled,
                    bool extensions_enabled);
 
   virtual ~ExtensionService();
 
   // Gets the list of currently installed extensions.
   virtual const ExtensionSet* extensions() const OVERRIDE;
   virtual const ExtensionSet* disabled_extensions() const OVERRIDE;
   const ExtensionSet* terminated_extensions() const;
+  const ExtensionSet* blacklisted_extensions() const;
 
-  // Returns a set of all installed, disabled, and terminated extensions and
-  // transfers ownership to caller.
-  const ExtensionSet* GenerateInstalledExtensionsSet() const;
+  // Returns a set of all installed, disabled, blacklisted, and terminated
+  // extensions.
+  scoped_ptr<const ExtensionSet> GenerateInstalledExtensionsSet() const;
 
   // Returns a set of all extensions disabled by the sideload wipeout
   // initiative.
-  const ExtensionSet* GetWipedOutExtensions() const;
+  scoped_ptr<const ExtensionSet> GetWipedOutExtensions() const;
 
   // Gets the object managing the set of pending extensions.
   virtual extensions::PendingExtensionManager*
       pending_extension_manager() OVERRIDE;
 
   const FilePath& install_directory() const { return install_directory_; }
 
   extensions::ProcessMap* process_map() { return &process_map_; }
 
   // Whether this extension can run in an incognito window.
@@ skipping 66 matching lines @@
   // Called when the ProfileSyncService for the associated Profile is
   // going to be destroyed.  This is guaranteed to be called exactly
   // once before Shutdown() is called.
   //
   // TODO(akalin): Remove this once http://crbug.com/153827 is fixed.
   void OnProfileSyncServiceShutdown();
 
   // Called when the associated Profile is going to be destroyed.
   void Shutdown();
 
-  // Look up an extension by ID.  Does not include terminated
+  // Look up an extension by ID. Does not include terminated
   // extensions.
   virtual const extensions::Extension* GetExtensionById(
       const std::string& id, bool include_disabled) const OVERRIDE;
 
+  enum IncludeFlag {
+    INCLUDE_NONE        = 0,
+    INCLUDE_ENABLED     = 1 << 0,
+    INCLUDE_DISABLED    = 1 << 1,
+    INCLUDE_TERMINATED  = 1 << 2,
+    INCLUDE_BLACKLISTED = 1 << 3,
+    INCLUDE_EVERYTHING = (1 << 4) - 1,
+  };
+
+  // Look up an extension by ID, selecting which sets to look in:
+  //  * extensions()             --> INCLUDE_ENABLED
+  //  * disabled_extensions()    --> INCLUDE_DISABLED
+  //  * terminated_extensions()  --> INCLUDE_TERMINATED
+  //  * blacklisted_extensions() --> INCLUDE_BLACKLISTED
+  const extensions::Extension* GetExtensionById(const std::string& id,
+                                                int include_mask) const;
+
   // Looks up a terminated (crashed) extension by ID.
   const extensions::Extension*
       GetTerminatedExtension(const std::string& id) const;
 
   // Looks up an extension by ID, regardless of whether it's enabled,
-  // disabled, or terminated.
+  // disabled, blacklisted, or terminated.
   virtual const extensions::Extension* GetInstalledExtension(
       const std::string& id) const OVERRIDE;
 
   // Updates a currently-installed extension with the contents from
   // |extension_path|.
   // TODO(aa): This method can be removed. ExtensionUpdater could use
   // CrxInstaller directly instead.
   virtual bool UpdateExtension(
       const std::string& id,
       const FilePath& extension_path,
@@ skipping 406 matching lines @@
   void OnExtensionInstallPrefChanged();
 
   // Handles setting the extension specific values in |extension_sync_data| to
   // the current system.
   // Returns false if the changes were not completely applied and need to be
   // tried again later.
   bool ProcessExtensionSyncDataHelper(
       const extensions::ExtensionSyncData& extension_sync_data,
       syncer::ModelType type);
 
-  enum IncludeFlag {
-    INCLUDE_NONE = 0,
-    INCLUDE_ENABLED = 1 << 0,
-    INCLUDE_DISABLED = 1 << 1,
-    INCLUDE_TERMINATED = 1 << 2
-  };
-
   // Events to be fired after an extension is reloaded.
   enum PostReloadEvents {
     EVENT_NONE = 0,
     EVENT_LAUNCHED = 1 << 0,
     EVENT_RESTARTED = 1 << 1,
   };
 
-  // Look up an extension by ID, optionally including either or both of enabled
-  // and disabled extensions.
-  const extensions::Extension* GetExtensionByIdInternal(
-      const std::string& id,
-      int include_mask) const;
-
   // Adds the given extension to the list of terminated extensions if
   // it is not already there and unloads it.
   void TrackTerminatedExtension(const extensions::Extension* extension);
 
   // Removes the extension with the given id from the list of
   // terminated extensions if it is there.
   void UntrackTerminatedExtension(const std::string& id);
 
   // Update preferences for a new or updated extension; notify observers that
   // the extension is installed, e.g., to update event handlers on background
@@ skipping 62 matching lines @@
   bool IsExtensionIdle(const std::string& extension_id) const;
 
   // Helper to determine if updating an extensions should proceed immediately,
   // or if we should delay the update until further notice.
   bool ShouldDelayExtensionUpdate(const std::string& extension_id,
                                   bool wait_for_idle) const;
 
   // extensions::Blacklist::Observer implementation.
   virtual void OnBlacklistUpdated() OVERRIDE;
 
+  // Manages the blacklisted extensions, intended as callback from
+  // Blacklist::GetBlacklistedIDs.
+  void ManageBlacklist(const std::set<std::string>& old_blacklisted_ids,
+                       const std::set<std::string>& new_blacklisted_ids);
+
   // The normal profile associated with this ExtensionService.
   Profile* profile_;
 
   // The ExtensionSystem for the profile above.
   extensions::ExtensionSystem* system_;
 
-  // Preferences for the owning profile (weak reference).
+  // Preferences for the owning profile.
   extensions::ExtensionPrefs* extension_prefs_;
 
+  // Blacklist for the owning profile.
+  extensions::Blacklist* blacklist_;
+
   // Settings for the owning profile.
   scoped_ptr<extensions::SettingsFrontend> settings_frontend_;
 
   // The current list of installed extensions.
   ExtensionSet extensions_;
 
   // The list of installed extensions that have been disabled.
   ExtensionSet disabled_extensions_;
 
   // The list of installed extensions that have been terminated.
   ExtensionSet terminated_extensions_;
 
+  // The list of installed extensions that have been blacklisted. Generally
+  // these shouldn't be considered as installed by the extension platform: we
+  // only keep them around so that if extensions are blacklisted by mistake
+  // they can easily be un-blacklisted.
+  ExtensionSet blacklisted_extensions_;
+
   // The list of extension updates that are waiting to be installed.
   ExtensionSet pending_extension_updates_;
 
   // Hold the set of pending extensions.
   extensions::PendingExtensionManager pending_extension_manager_;
 
   // The map of extension IDs to their runtime data.
   ExtensionRuntimeDataMap extension_runtime_data_;
 
   // The full path to the directory where extensions are installed.
@@ skipping 130 matching lines @@
 #endif
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_