Clean up threading model of external extension providers

chrome/browser/extensions/extension_service.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/linked_ptr.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #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/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/sandboxed_extension_unpacker.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/property_bag.h"
 
 class ExtensionServiceBackend;
 class ExtensionToolbarModel;
 class ExtensionUpdater;
@@ skipping 52 matching lines @@
   virtual bool HasInstalledExtensions() = 0;
 
   virtual ExtensionPrefs* extension_prefs() = 0;
 };
 
 // Manages installed and running Chromium extensions.
 class ExtensionService
     : public base::RefCountedThreadSafe<ExtensionService,
                                         BrowserThread::DeleteOnUIThread>,
       public ExtensionUpdateService,
+      public ExternalExtensionProviderInterface::VisitorInterface,
       public NotificationObserver {
  public:
   // Information about a registered component extension.
   struct ComponentExtensionInfo {
     ComponentExtensionInfo(const std::string& manifest,
                            const FilePath& root_directory)
         : manifest(manifest),
           root_directory(root_directory) {
     }
 
@@ skipping 179 matching lines @@
   // Continues loading all know extensions. It can be called from
   // LoadAllExtensions or from file thread if we had to relocalize manifest
   // (write_to_prefs is true in that case).
   void ContinueLoadAllExtensions(ExtensionPrefs::ExtensionsInfo* info,
                                  base::TimeTicks start_time,
                                  bool write_to_prefs);
 
   // Check for updates (or potentially new extensions from external providers)
   void CheckForExternalUpdates();
 
-  // Copies the list of force-installed extensions from the user PrefService
-  // to ExternalPolicyExtensionProvider.
-  void UpdateExternalPolicyExtensionProvider();
-
   // Unload the specified extension.
   void UnloadExtension(const std::string& extension_id,
                        UnloadedExtensionInfo::Reason reason);
 
   // Unload all extensions. This is currently only called on shutdown, and
   // does not send notifications.
   void UnloadAllExtensions();
 
   // Called only by testing.
   void ReloadExtensions();
@@ skipping 21 matching lines @@
   // permissions the given extension has been granted.
   bool ExtensionBindingsAllowed(const GURL& url);
 
   // Returns the icon to display in the omnibox for the given extension.
   const SkBitmap& GetOmniboxIcon(const std::string& extension_id);
 
   // Returns the icon to display in the omnibox popup window for the given
   // extension.
   const SkBitmap& GetOmniboxPopupIcon(const std::string& extension_id);
 
-  // Clear all ExternalExtensionProviders.
-  void ClearProvidersForTesting();
-
-  // Sets an ExternalExtensionProvider for the service to use during testing.
-  // Takes ownership of |test_provider|.
-  void AddProviderForTesting(ExternalExtensionProvider* test_provider);
-
   // Called when the initial extensions load has completed.
   virtual void OnLoadedInstalledExtensions();
 
   // Called when an extension has been loaded.
   void OnExtensionLoaded(const Extension* extension);
 
   // Called by the backend when an extension has been installed.
   void OnExtensionInstalled(const Extension* extension);
 
-  // Called by the backend when an external extension is found.
-  void OnExternalExtensionFileFound(const std::string& id,
-                                    const std::string& version,
-                                    const FilePath& path,
-                                    Extension::Location location);
-
   // Checks if the privileges requested by |extension| have increased, and if
   // so, disables the extension and prompts the user to approve the change.
   void DisableIfPrivilegeIncrease(const Extension* extension);
 
   // Go through each extensions in pref, unload blacklisted extensions
   // and update the blacklist state in pref.
   virtual void UpdateExtensionBlacklist(
     const std::vector<std::string>& blacklist);
 
   // Go through each extension and unload those that the network admin has
@@ skipping 41 matching lines @@
   // This method is public because ExtensionServiceBackend can post to here.
   void ReportExtensionLoadError(const FilePath& extension_path,
                                 const std::string& error,
                                 NotificationType type,
                                 bool be_noisy);
 
   // ExtensionHost of background page calls this method right after its render
   // view has been created.
   void DidCreateRenderViewForBackgroundPage(ExtensionHost* host);
 
+  // For the extension in |version_path| with |id|, check to see if it's an
+  // externally managed extension.  If so, uninstall it.
+  void CheckExternalUninstall(const std::string& id);
+
+  // Clear all ExternalExtensionProviders.
+  void ClearProvidersForTesting();
+
+  // Adds an ExternalExtensionProviderInterface for the service to use during
+  // testing. Takes ownership of |test_provider|.
+  void AddProviderForTesting(ExternalExtensionProviderInterface* test_provider);
+
+  // ExternalExtensionProvider::Visitor implementation.
+  virtual void OnExternalExtensionFileFound(const std::string& id,
+                                            const Version* version,
+                                            const FilePath& path,
+                                            Extension::Location location);
+
+  virtual void OnExternalExtensionUpdateUrlFound(const std::string& id,
+                                                 const GURL& update_url,
+                                                 Extension::Location location);
+
+  virtual void OnExternalProviderReady();
+
   // NotificationObserver
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Whether there are any apps installed. Component apps are not included.
   bool HasApps() const;
 
   // Gets the set of loaded app ids. Component apps are not included.
   ExtensionIdSet GetAppIds() const;
@@ skipping 155 matching lines @@
   typedef std::map<GURL, int> ProtectedStorageMap;
   ProtectedStorageMap protected_storage_map_;
 
   // Manages the installation of default apps and the promotion of them in the
   // app launcher.
   DefaultApps default_apps_;
 
   // Flag to make sure event routers are only initialized once.
   bool event_routers_initialized_;
 
+  // A collection of external extension providers.  Each provider reads
+  // a source of external extension information.  Examples include the
+  // windows registry and external_extensions.json.
+  ProviderCollection external_extension_providers_;
+
+  // Set to true by OnExternalExtensionUpdateUrlFound() when an external
+  // extension URL is found.  Used in CheckForExternalUpdates() to see
+  // if an update check is needed to install pending extensions.
+  bool external_extension_added_;
+
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            UpdatePendingExtensionAlreadyInstalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_