Added support for pending extensions to ExtensionsService and

chrome/browser/extensions/extensions_service.h

 // Copyright (c) 2010 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_EXTENSIONS_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 11 matching lines @@
 #include "chrome/browser/extensions/extension_menu_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/sandboxed_extension_unpacker.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/extensions/extension.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 
 class Browser;
 class ExtensionsServiceBackend;
 class ExtensionToolbarModel;
 class ExtensionUpdater;
 class GURL;
 class PrefService;
 class Profile;
 class ResourceDispatcherHost;
 class SiteInstance;
+class Version;
+
+// A pending extension is an extension that hasn't been installed yet
+// and is intended to be installed in the next auto-update cycle.  The
+// update URL of a pending extension may be blank, in which case a
+// default one is assumed.
+struct PendingExtensionInfo {
+  PendingExtensionInfo(const GURL& update_url,
+                       const Version& version,
+                       bool is_theme,
+                       bool install_silently);
+
+  PendingExtensionInfo();
+
+  GURL update_url;
+  Version version;
+  bool is_theme;
+  bool install_silently;
+};
+
+// A PendingExtensionMap is a map from IDs of pending extensions to
+// their info.
+typedef std::map<std::string, PendingExtensionInfo> PendingExtensionMap;
 
 // This is an interface class to encapsulate the dependencies that
 // ExtensionUpdater has on ExtensionsService. This allows easy mocking.
 class ExtensionUpdateService {
  public:
   virtual ~ExtensionUpdateService() {}
   virtual const ExtensionList* extensions() const = 0;
+  virtual const PendingExtensionMap& pending_extensions() const = 0;
   virtual void UpdateExtension(const std::string& id, const FilePath& path,
                                const GURL& download_url) = 0;
   virtual Extension* GetExtensionById(const std::string& id,
                                       bool include_disabled) = 0;
   virtual void UpdateExtensionBlacklist(
     const std::vector<std::string>& blacklist) = 0;
   virtual bool HasInstalledExtensions() = 0;
 
   // These set/get a server-provided time representing the start of the last day
   // that we sent the 'ping' parameter during an update check.
@@ skipping 49 matching lines @@
                     PrefService* prefs,
                     const FilePath& install_directory,
                     bool autoupdate_enabled);
 
   // Gets the list of currently installed extensions.
   virtual const ExtensionList* extensions() const { return &extensions_; }
   virtual const ExtensionList* disabled_extensions() const {
     return &disabled_extensions_;
   }
 
+  // Gets the set of pending extensions.
+  virtual const PendingExtensionMap& pending_extensions() const {
+    return pending_extensions_;
+  }
+
   // Registers an extension to be loaded as a component extension.
   void register_component_extension(const ComponentExtensionInfo& info) {
     component_extension_manifests_.push_back(info);
   }
 
   // Returns true if any extensions are installed.
   virtual bool HasInstalledExtensions() {
     return !(extensions_.empty() && disabled_extensions_.empty());
   }
 
@@ skipping 24 matching lines @@
   void InstallExtension(const FilePath& extension_path);
 
   // 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 void UpdateExtension(const std::string& id,
                                const FilePath& extension_path,
                                const GURL& download_url);
 
+  // If an extension with the given id is already installed,
+  // does nothing.  Otherwise, the extension will be installed in the
+  // next auto-update cycle.
+  //
+  // TODO(akalin): Make sure that all the places that check for
+  // existing versions also consult the pending extension info.
+  void AddPendingExtension(
+      const std::string& id, const GURL& update_url,
+      const Version& version, bool is_theme, bool install_silently);
+
   // Reloads the specified extension.
   void ReloadExtension(const std::string& extension_id);
 
   // Uninstalls the specified extension. Callers should only call this method
   // with extensions that exist. |external_uninstall| is a magical parameter
   // that is only used to send information to ExtensionPrefs, which external
   // callers should never set to true.
   // TODO(aa): Remove |external_uninstall| -- this information should be passed
   // to ExtensionPrefs some other way.
   void UninstallExtension(const std::string& extension_id,
@@ skipping 123 matching lines @@
 
   // Clear all persistent data that may have been stored by the extension.
   void ClearExtensionData(const GURL& extension_url);
 
   // Look up an extension by ID, optionally including either or both of enabled
   // and disabled extensions.
   Extension* GetExtensionByIdInternal(const std::string& id,
                                       bool include_enabled,
                                       bool include_disabled);
 
+  // Like AddPendingExtension() but assumes an extension with the same
+  // id is not already installed.
+  void AddPendingExtensionInternal(
+      const std::string& id, const GURL& update_url,
+      const Version& version, bool is_theme, bool install_silently);
+
   // Handles sending notification that |extension| was loaded.
   void NotifyExtensionLoaded(Extension* extension);
 
   // Handles sending notification that |extension| was unloaded.
   void NotifyExtensionUnloaded(Extension* extension);
 
   // Helper that updates the active extension list used for crash reporting.
   void UpdateActiveExtensionsInCrashReporter();
 
   // Helper method. Loads extension from prefs.
   void LoadInstalledExtension(const ExtensionInfo& info, bool relocalize);
 
   // The profile this ExtensionsService is part of.
   Profile* profile_;
 
   // Preferences for the owning profile.
   scoped_ptr<ExtensionPrefs> extension_prefs_;
 
   // The current list of installed extensions.
   ExtensionList extensions_;
 
   // The list of installed extensions that have been disabled.
   ExtensionList disabled_extensions_;
 
+  // The set of pending extensions.
+  PendingExtensionMap pending_extensions_;
+
   // The full path to the directory where extensions are installed.
   FilePath install_directory_;
 
   // Whether or not extensions are enabled.
   bool extensions_enabled_;
 
   // Whether to notify users when they attempt to install an extension.
   bool show_extensions_prompts_;
 
   // The backend that will do IO on behalf of this instance.
@@ skipping 24 matching lines @@
 
   NotificationRegistrar registrar_;
 
   // Keeps track of menu items added by extensions.
   ExtensionMenuManager menu_manager_;
 
   // List of registered component extensions (see Extension::Location).
   typedef std::vector<ComponentExtensionInfo> RegisteredComponentExtensions;
   RegisteredComponentExtensions component_extension_manifests_;
 
+  FRIEND_TEST(ExtensionsServiceTest, UpdatePendingExtensionAlreadyInstalled);
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionsService);
 };
 
 // Implements IO for the ExtensionsService.
 // TODO(aa): This can probably move into the .cc file.
 class ExtensionsServiceBackend
     : public base::RefCountedThreadSafe<ExtensionsServiceBackend>,
       public ExternalExtensionProvider::Visitor {
  public:
   // |rdh| can be NULL in the case of test environment.
@@ skipping 87 matching lines @@
 
   // A map of all external extension providers.
   typedef std::map<Extension::Location,
                    linked_ptr<ExternalExtensionProvider> > ProviderMap;
   ProviderMap external_extension_providers_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionsServiceBackend);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_