Rename ExtensionsService to ExtensionService.

chrome/browser/extensions/extension_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_
+#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"
@@ skipping 10 matching lines @@
 #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/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 ExtensionsServiceBackend;
+class ExtensionServiceBackend;
 class ExtensionToolbarModel;
 class ExtensionUpdater;
 class GURL;
 class Profile;
 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.
@@ skipping 25 matching lines @@
   bool enable_on_install;
   bool enable_incognito_on_install;
   Extension::Location install_source;
 };
 
 // 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.
+// ExtensionUpdater has on ExtensionService. 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 const Extension* GetExtensionById(const std::string& id,
                                             bool include_disabled) = 0;
   virtual void UpdateExtensionBlacklist(
     const std::vector<std::string>& blacklist) = 0;
   virtual void CheckAdminBlacklist() = 0;
   virtual bool HasInstalledExtensions() = 0;
 
   virtual ExtensionPrefs* extension_prefs() = 0;
 };
 
 // Manages installed and running Chromium extensions.
-class ExtensionsService
-    : public base::RefCountedThreadSafe<ExtensionsService,
+class ExtensionService
+    : public base::RefCountedThreadSafe<ExtensionService,
                                         BrowserThread::DeleteOnUIThread>,
       public ExtensionUpdateService,
       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) {
     }
 
     // The extension's manifest. This is required for component extensions so
-    // that ExtensionsService doesn't need to go to disk to load them.
+    // that ExtensionService doesn't need to go to disk to load them.
     std::string manifest;
 
     // Directory where the extension is stored.
     FilePath root_directory;
   };
 
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char* kInstallDirectoryName;
 
@@ skipping 11 matching lines @@
 
   // Determine if the downloaded extension came from the theme mini-gallery,
   // Used to test if we need to show the "Loading" dialog for themes.
   static bool IsDownloadFromMiniGallery(const GURL& download_url);
 
   // Returns whether the URL is from either a hosted or packaged app.
   bool IsInstalledApp(const GURL& url);
 
   // Attempts to uninstall an extension from a given ExtensionService. Returns
   // true iff the target extension exists.
-  static bool UninstallExtensionHelper(ExtensionsService* extensions_service,
+  static bool UninstallExtensionHelper(ExtensionService* extensions_service,
                                        const std::string& extension_id);
 
   // Constructor stores pointers to |profile| and |extension_prefs| but
   // ownership remains at caller.
-  ExtensionsService(Profile* profile,
+  ExtensionService(Profile* profile,
                     const CommandLine* command_line,
                     const FilePath& install_directory,
                     ExtensionPrefs* extension_prefs,
                     bool autoupdate_enabled);
 
   // Gets the list of currently installed extensions.
   virtual const ExtensionList* extensions() const;
   virtual const ExtensionList* disabled_extensions() const;
 
   // Gets the set of pending extensions.
@@ skipping 246 matching lines @@
 
   ExtensionsQuotaService* quota_service() { return &quota_service_; }
 
   ExtensionMenuManager* menu_manager() { return &menu_manager_; }
 
   const std::map<GURL, int>& protected_storage_map() const {
     return protected_storage_map_;
   }
 
   // Notify the frontend that there was an error loading an extension.
-  // This method is public because ExtensionsServiceBackend can post to here.
+  // 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);
 
   // 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;
 
  private:
   friend class BrowserThread;
-  friend class DeleteTask<ExtensionsService>;
+  friend class DeleteTask<ExtensionService>;
 
   // Contains Extension data that can change during the life of the process,
   // but does not persist across restarts.
   struct ExtensionRuntimeData {
     // True if the background page is ready.
     bool background_page_ready;
 
     // True while the extension is being upgraded.
     bool being_upgraded;
 
     // Generic bag of runtime data that users can associate with extensions.
     PropertyBag property_bag;
 
     ExtensionRuntimeData();
     ~ExtensionRuntimeData();
   };
   typedef std::map<std::string, ExtensionRuntimeData> ExtensionRuntimeDataMap;
 
-  virtual ~ExtensionsService();
+  virtual ~ExtensionService();
 
   // 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.
   const Extension* GetExtensionByIdInternal(const std::string& id,
                                             bool include_enabled,
                                             bool include_disabled);
 
@@ skipping 17 matching lines @@
 
   // Helper method. Loads extension from prefs.
   void LoadInstalledExtension(const ExtensionInfo& info, bool write_to_prefs);
 
   // Helper methods to configure the storage services accordingly.
   void GrantProtectedStorage(const Extension* extension);
   void RevokeProtectedStorage(const Extension* extension);
   void GrantUnlimitedStorage(const Extension* extension);
   void RevokeUnlimitedStorage(const Extension* extension);
 
-  // The profile this ExtensionsService is part of.
+  // The profile this ExtensionService is part of.
   Profile* profile_;
 
   // Preferences for the owning profile (weak reference).
   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 map of extension IDs to their runtime data.
   ExtensionRuntimeDataMap extension_runtime_data_;
 
   // 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.
-  scoped_refptr<ExtensionsServiceBackend> backend_;
+  scoped_refptr<ExtensionServiceBackend> backend_;
 
   // Used by dispatchers to limit API quota for individual extensions.
   ExtensionsQuotaService quota_service_;
 
   // Record that Init() has been called, and NotificationType::EXTENSIONS_READY
   // has fired.
   bool ready_;
 
   // Our extension updater, if updates are turned on.
   scoped_refptr<ExtensionUpdater> updater_;
@@ skipping 44 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_;
 
-  FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            UpdatePendingExtensionAlreadyInstalled);
-  FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
-  FRIEND_TEST_ALL_PREFIXES(ExtensionsServiceTest,
+  FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
-  DISALLOW_COPY_AND_ASSIGN(ExtensionsService);
+  DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
-#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
+#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_