Sanity tweaks to the extension blacklist: check all extensions at once on

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 43 matching lines @@
 class SequencedTaskRunner;
 }
 
 namespace extensions {
 class AppNotificationManager;
 class AppSyncData;
 class BrowserEventRouter;
 class ComponentLoader;
 class ContentSettingsStore;
 class CrxInstaller;
-class Extension;
 class ExtensionActionStorageManager;
 class ExtensionSyncData;
 class ExtensionSystem;
 class ExtensionUpdater;
 class PendingExtensionManager;
 class SettingsFrontend;
 }
 
 namespace syncer {
 class SyncErrorFactory;
@@ skipping 35 matching lines @@
       const std::string& extension_id) const = 0;
 
   virtual void CheckManagementPolicy() = 0;
 
   // Safe to call multiple times in a row.
   //
   // TODO(akalin): Remove this method (and others) once we refactor
   // themes sync to not use it directly.
   virtual void CheckForUpdatesSoon() = 0;
 
+  virtual void AddExtensions(const extensions::ExtensionList& extensions) = 0;
   virtual void AddExtension(const extensions::Extension* extension) = 0;
   virtual void AddComponentExtension(
       const extensions::Extension* extension) = 0;
 
   virtual void UnloadExtension(
       const std::string& extension_id,
       extension_misc::UnloadedExtensionReason reason) = 0;
 
   virtual void SyncExtensionChangeIfNeeded(
       const extensions::Extension& extension) = 0;
@@ skipping 291 matching lines @@
   // permissions the given extension has been granted.
   bool ExtensionBindingsAllowed(const GURL& url);
 
   // Returns true if a normal browser window should avoid showing |url| in a
   // tab. In this case, |url| is also rewritten to an error URL.
   bool ShouldBlockUrlInBrowserTab(GURL* url);
 
   // Called when the initial extensions load has completed.
   virtual void OnLoadedInstalledExtensions();
 
-  // Adds |extension| to this ExtensionService and notifies observers than an
-  // extension has been loaded.  Called by the backend after an extension has
-  // been loaded from a file and installed.
+  // Adds every extension in |extensions| to this ExtensionService and notifies
+  // observers that the extensions have been loaded, then asynchronously checks
+  // those against the blacklist.
+  //
+  // If possible, please check the blacklist ahead of time, since this method
+  // may end up loading blacklisted extensions for a short period of time.
+  virtual void AddExtensions(
+      const extensions::ExtensionList& extensions) OVERRIDE;
+
+  // Calls AddExtensions with a single extension, please see comment.
   virtual void AddExtension(const extensions::Extension* extension) OVERRIDE;
 
   // Check if we have preferences for the component extension and, if not or if
   // the stored version differs, install the extension (without requirements
-  // checking) before calling AddExtension.
+  // checking) before calling AddNonBlacklistedExtension.
   virtual void AddComponentExtension(const extensions::Extension* extension)
       OVERRIDE;
 
-  // Called by the backend when an extension has been installed.
-  void OnExtensionInstalled(

[Matt Perry, 2013/02/07 01:05:35]

After thinking about it, I can see the reasoning behind this name. The extension
has already been unpacked onto disk into the installation dir. We're just
informing the ExtensionService to add it to the install list.

How about HandleExtensionInstall and HandleExtensionInstallAsync?

[Matt Perry, 2013/02/07 01:10:23]

Actually, lets just make it explicit. Keep OnExtensionInstalled, and add a
CheckExtensionBlacklist method with success/failure callbacks.

[not at google - send to devlin, 2013/02/07 02:11:37]

Done.

+  // Instructs the extension service to install an extension some point in the
+  // future, then runs |on_done|.
+  //
+  // If installation succeeds the callback will be passed true. If it fails
+  // (e.g. due to blacklisting) then it will be passed false.
+  void InstallExtensionAsync(
       const extensions::Extension* extension,
       const syncer::StringOrdinal& page_ordinal,
       bool has_requirement_errors,
+      bool wait_for_idle,
+      const base::Callback<void(bool /*success*/)>& on_done);
+
+  // Instructs the extension service to install an extension now. No blacklist
+  // checking is done.
+  void InstallExtensionNow(
+      const extensions::Extension* extension,
+      const syncer::StringOrdinal& page_ordinal,
+      bool has_requirement_errors,
       bool wait_for_idle);
 
   // Similar to FinishInstallation, but first checks if there still is an update
   // pending for the extension, and makes sure the extension is still idle.
   void MaybeFinishDelayedInstallation(const std::string& extension_id);
 
   // Finishes installation of an update for an extension with the specified id,
   // when installation of that extension was previously delayed because the
   // extension was in use.
   virtual void FinishDelayedInstallation(
@@ skipping 292 matching lines @@
   };
 
   // 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);
 
+  // Adds an extension to the service without checking any blacklist.
+  bool AddNonBlacklistedExtension(const extensions::Extension* extension);
+
   // Update preferences for a new or updated extension; notify observers that
   // the extension is installed, e.g., to update event handlers on background
   // pages; and perform other extension install tasks before calling
-  // AddExtension.
+  // AddNonBlacklistedExtension.
   void AddNewOrUpdatedExtension(const extensions::Extension* extension,
                                 extensions::Extension::State initial_state,
                                 const syncer::StringOrdinal& page_ordinal);
 
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(const extensions::Extension* extension);
 
   // Handles sending notification that |extension| was unloaded.
   void NotifyExtensionUnloaded(const extensions::Extension* extension,
                                extension_misc::UnloadedExtensionReason reason);
@@ skipping 230 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_