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 192 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, 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 605 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::IsBlacklisted.
+  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).
   extensions::ExtensionPrefs* extension_prefs_;
 
+  // Blacklist for the owning profile (weak reference).

[asargent_no_longer_on_chrome, 2012/11/30 21:44:22]

optional suggestion: Whenever I see "weak reference" I think of WeakPtr<T>,
which is a little different from "a pointer I don't own". I kind of prefer to
use the term "unowned" instead of "weak" when talking about these.

aside: Sometimes I've wondered if our codebase would benefit from a
UnownedPtr<T> class that just serves to document non-ownership, so that you
don't have to wonder about a given naked pointer - it's always wrapped with one
of scoped_ptr/scoped_refptr/linked_ptr, WeakPtr, UnownedPtr, etc.

[not at google - send to devlin, 2012/11/30 23:09:54]

Done.

TBH I thought the "weak reference" thing was always redundant anyway, since
usually that's conveyed by the type - raw pointer means not-owned.

And aside: I have also occasionally wanted the UnownedPtr thing, though mostly
so that it could NULL itself out (like WeakPtr does - it's helped with tracking
down a bug before), but presumably this is (a) basically WeakPtr anyway, and (b)
introduces threading issues (like WeakPtr).

[asargent_no_longer_on_chrome, 2012/11/30 23:30:25]

Good point. 

+  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 128 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_