Rename ExtensionsService to ExtensionService.

chrome/browser/extensions/extension_service.cc

 // 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.
 
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
@@ skipping 147 matching lines @@
 PendingExtensionInfo::PendingExtensionInfo()
     : update_url(),
       expected_crx_type(PendingExtensionInfo::UNKNOWN),
       is_from_sync(true),
       install_silently(false),
       enable_on_install(false),
       enable_incognito_on_install(false),
       install_source(Extension::INVALID) {}
 
 
-ExtensionsService::ExtensionRuntimeData::ExtensionRuntimeData()
+ExtensionService::ExtensionRuntimeData::ExtensionRuntimeData()
     : background_page_ready(false),
       being_upgraded(false) {
 }
 
-ExtensionsService::ExtensionRuntimeData::~ExtensionRuntimeData() {
+ExtensionService::ExtensionRuntimeData::~ExtensionRuntimeData() {
 }
 
-// ExtensionsService.
+// ExtensionService.
 
-const char* ExtensionsService::kInstallDirectoryName = "Extensions";
-const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
+const char* ExtensionService::kInstallDirectoryName = "Extensions";
+const char* ExtensionService::kCurrentVersionFileName = "Current Version";
 
-// Implements IO for the ExtensionsService.
+// Implements IO for the ExtensionService.
 
-class ExtensionsServiceBackend
-    : public base::RefCountedThreadSafe<ExtensionsServiceBackend>,
+class ExtensionServiceBackend
+    : public base::RefCountedThreadSafe<ExtensionServiceBackend>,
       public ExternalExtensionProvider::Visitor {
  public:
   // |install_directory| is a path where to look for extensions to load.
-  ExtensionsServiceBackend(PrefService* prefs,
+  ExtensionServiceBackend(PrefService* prefs,
                            const FilePath& install_directory);
 
   // Loads a single extension from |path| where |path| is the top directory of
   // a specific extension where its manifest file lives.
   // Errors are reported through ExtensionErrorReporter. On success,
   // OnExtensionLoaded() is called.
   // TODO(erikkay): It might be useful to be able to load a packed extension
   // (presumably into memory) without installing it.
   void LoadSingleExtension(const FilePath &path,
-                           scoped_refptr<ExtensionsService> frontend);
+                           scoped_refptr<ExtensionService> frontend);
 
   // Check externally updated extensions for updates and install if necessary.
   // Errors are reported through ExtensionErrorReporter. Succcess is not
   // reported.
-  void CheckForExternalUpdates(scoped_refptr<ExtensionsService> frontend);
+  void CheckForExternalUpdates(scoped_refptr<ExtensionService> frontend);
 
   // For the extension in |version_path| with |id|, check to see if it's an
   // externally managed extension.  If so, tell the frontend to uninstall it.
-  void CheckExternalUninstall(scoped_refptr<ExtensionsService> frontend,
+  void CheckExternalUninstall(scoped_refptr<ExtensionService> frontend,
                               const std::string& id);
 
   // Clear all ExternalExtensionProviders.
   void ClearProvidersForTesting();
 
   // Adds an ExternalExtensionProvider for the service to use during testing.
   // Takes ownership of |test_provider|.
   void AddProviderForTesting(ExternalExtensionProvider* 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 UpdateExternalPolicyExtensionProvider(
       scoped_refptr<RefCountedList> forcelist);
 
  private:
-  friend class base::RefCountedThreadSafe<ExtensionsServiceBackend>;
+  friend class base::RefCountedThreadSafe<ExtensionServiceBackend>;
 
-  virtual ~ExtensionsServiceBackend();
+  virtual ~ExtensionServiceBackend();
 
   // Finish installing the extension in |crx_path| after it has been unpacked to
   // |unpacked_path|.  If |expected_id| is not empty, it's verified against the
   // extension's manifest before installation. If |silent| is true, there will
   // be no install confirmation dialog. |from_gallery| indicates whether the
   // crx was installed from our gallery, which results in different UI.
   //
   // Note: We take ownership of |extension|.
   void OnExtensionUnpacked(const FilePath& crx_path,
                            const FilePath& unpacked_path,
                            const Extension* extension,
                            const std::string expected_id);
 
   // Notify the frontend that there was an error loading an extension.
   void ReportExtensionLoadError(const FilePath& extension_path,
                                 const std::string& error);
 
   // This is a naked pointer which is set by each entry point.
   // The entry point is responsible for ensuring lifetime.
-  ExtensionsService* frontend_;
+  ExtensionService* frontend_;
 
   // The top-level extensions directory being installed to.
   FilePath install_directory_;
 
   // Whether errors result in noisy alerts.
   bool alert_on_error_;
 
   // A collection of external extension providers.  Each provider reads
   // a source of external extension information.  Examples include the
   // windows registry and external_extensions.json.
   typedef std::vector<linked_ptr<ExternalExtensionProvider> >
       ProviderCollection;
   ProviderCollection external_extension_providers_;
   linked_ptr<ExternalPolicyExtensionProvider>
       external_policy_extension_provider_;
 
   // 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_;
 
-  DISALLOW_COPY_AND_ASSIGN(ExtensionsServiceBackend);
+  DISALLOW_COPY_AND_ASSIGN(ExtensionServiceBackend);
 };
 
-ExtensionsServiceBackend::ExtensionsServiceBackend(
+ExtensionServiceBackend::ExtensionServiceBackend(
     PrefService* prefs,
     const FilePath& install_directory)
         : frontend_(NULL),
           install_directory_(install_directory),
           alert_on_error_(false),
           external_extension_added_(false) {
   // TODO(aa): This ends up doing blocking IO on the UI thread because it reads
   // pref data in the ctor and that is called on the UI thread. Would be better
   // to re-read data each time we list external extensions, anyway.
   external_extension_providers_.push_back(
       linked_ptr<ExternalExtensionProvider>(
           new ExternalPrefExtensionProvider()));
 #if defined(OS_WIN)
   external_extension_providers_.push_back(
       linked_ptr<ExternalExtensionProvider>(
           new ExternalRegistryExtensionProvider()));
 #endif
   // The policy-controlled extension provider is also stored in a member
   // variable so that UpdateExternalPolicyExtensionProvider can access it and
   // update its extension list later.
   external_policy_extension_provider_.reset(
       new ExternalPolicyExtensionProvider());
   external_policy_extension_provider_->SetPreferences(
       prefs->GetList(prefs::kExtensionInstallForceList));
   external_extension_providers_.push_back(external_policy_extension_provider_);
 }
 
-ExtensionsServiceBackend::~ExtensionsServiceBackend() {
+ExtensionServiceBackend::~ExtensionServiceBackend() {
 }
 
-void ExtensionsServiceBackend::LoadSingleExtension(
-    const FilePath& path_in, scoped_refptr<ExtensionsService> frontend) {
+void ExtensionServiceBackend::LoadSingleExtension(
+    const FilePath& path_in, scoped_refptr<ExtensionService> frontend) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   frontend_ = frontend;
 
   // Explicit UI loads are always noisy.
   alert_on_error_ = true;
 
   FilePath extension_path = path_in;
   file_util::AbsolutePath(&extension_path);
 
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path,
       Extension::LOAD,
       false,  // Don't require id
       &error));
 
   if (!extension) {
     ReportExtensionLoadError(extension_path, error);
     return;
   }
 
   // Report this as an installed extension so that it gets remembered in the
   // prefs.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(frontend_,
-                        &ExtensionsService::OnExtensionInstalled,
+                        &ExtensionService::OnExtensionInstalled,
                         extension));
 }
 
-void ExtensionsServiceBackend::ReportExtensionLoadError(
+void ExtensionServiceBackend::ReportExtensionLoadError(
     const FilePath& extension_path, const std::string &error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
-          &ExtensionsService::ReportExtensionLoadError, extension_path,
+          &ExtensionService::ReportExtensionLoadError, extension_path,
           error, NotificationType::EXTENSION_INSTALL_ERROR, alert_on_error_));
 }
 
 // Some extensions will autoupdate themselves externally from Chrome.  These
 // are typically part of some larger client application package.  To support
 // these, the extension will register its location in the the preferences file
 // (and also, on Windows, in the registry) and this code will periodically
 // check that location for a .crx file, which it will then install locally if
 // a new version is available.
-void ExtensionsServiceBackend::CheckForExternalUpdates(
-    scoped_refptr<ExtensionsService> frontend) {
+void ExtensionServiceBackend::CheckForExternalUpdates(
+    scoped_refptr<ExtensionService> frontend) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Note that this installation is intentionally silent (since it didn't
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
   alert_on_error_ = false;
   frontend_ = frontend;
   external_extension_added_ = false;
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     ExternalExtensionProvider* provider = i->get();
     provider->VisitRegisteredExtension(this);
   }
 
   if (external_extension_added_ && frontend->updater()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
             NewRunnableMethod(
                 frontend->updater(), &ExtensionUpdater::CheckNow));
   }
 }
 
-void ExtensionsServiceBackend::CheckExternalUninstall(
-    scoped_refptr<ExtensionsService> frontend, const std::string& id) {
+void ExtensionServiceBackend::CheckExternalUninstall(
+    scoped_refptr<ExtensionService> frontend, const std::string& id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Check if the providers know about this extension.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     if (i->get()->HasExtension(id))
       return;  // Yup, known extension, don't uninstall.
   }
 
   // This is an external extension that we don't have registered.  Uninstall.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
-          frontend.get(), &ExtensionsService::UninstallExtension, id, true));
+          frontend.get(), &ExtensionService::UninstallExtension, id, true));
 }
 
-void ExtensionsServiceBackend::UpdateExternalPolicyExtensionProvider(
+void ExtensionServiceBackend::UpdateExternalPolicyExtensionProvider(
     scoped_refptr<RefCountedList> forcelist) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   external_policy_extension_provider_->SetPreferences(forcelist->Get());
 }
 
-void ExtensionsServiceBackend::ClearProvidersForTesting() {
+void ExtensionServiceBackend::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
 
-void ExtensionsServiceBackend::AddProviderForTesting(
+void ExtensionServiceBackend::AddProviderForTesting(
     ExternalExtensionProvider* test_provider) {
   DCHECK(test_provider);
   external_extension_providers_.push_back(
       linked_ptr<ExternalExtensionProvider>(test_provider));
 }
 
-void ExtensionsServiceBackend::OnExternalExtensionFileFound(
+void ExtensionServiceBackend::OnExternalExtensionFileFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   DCHECK(version);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
-          frontend_, &ExtensionsService::OnExternalExtensionFileFound, id,
+          frontend_, &ExtensionService::OnExternalExtensionFileFound, id,
           version->GetString(), path, location));
 }
 
-void ExtensionsServiceBackend::OnExternalExtensionUpdateUrlFound(
+void ExtensionServiceBackend::OnExternalExtensionUpdateUrlFound(
     const std::string& id,
     const GURL& update_url,
     Extension::Location location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (frontend_->GetExtensionById(id, true)) {
     // Already installed.  Do not change the update URL that the extension set.
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
-          &ExtensionsService::AddPendingExtensionFromExternalUpdateUrl,
+          &ExtensionService::AddPendingExtensionFromExternalUpdateUrl,
           id, update_url, location));
   external_extension_added_ |= true;
 }
 
-bool ExtensionsService::IsDownloadFromGallery(const GURL& download_url,
+bool ExtensionService::IsDownloadFromGallery(const GURL& download_url,
                                               const GURL& referrer_url) {
   // Special-case the themes mini-gallery.
   // TODO(erikkay) When that gallery goes away, remove this code.
   if (IsDownloadFromMiniGallery(download_url) &&
       StartsWithASCII(referrer_url.spec(),
                       extension_urls::kMiniGalleryBrowsePrefix, false)) {
     return true;
   }
 
   const Extension* download_extension = GetExtensionByWebExtent(download_url);
@@ skipping 28 matching lines @@
               GURL(download_url));
 
       // Otherwise, the TLD must match the TLD of the command-line url.
       download_valid = (download_tld == store_tld);
     }
   }
 
   return (referrer_valid && download_valid);
 }
 
-bool ExtensionsService::IsDownloadFromMiniGallery(const GURL& download_url) {
+bool ExtensionService::IsDownloadFromMiniGallery(const GURL& download_url) {
   return StartsWithASCII(download_url.spec(),
                          extension_urls::kMiniGalleryDownloadPrefix,
                          false);  // case_sensitive
 }
 
-bool ExtensionsService::IsInstalledApp(const GURL& url) {
+bool ExtensionService::IsInstalledApp(const GURL& url) {
   // Check for hosted app.
   if (GetExtensionByWebExtent(url) != NULL)
     return true;
 
   // Check for packaged app.
   const Extension* extension = GetExtensionByURL(url);
   return extension != NULL && extension->is_app();
 }
 
 // static
-bool ExtensionsService::UninstallExtensionHelper(
-    ExtensionsService* extensions_service,
+bool ExtensionService::UninstallExtensionHelper(
+    ExtensionService* extensions_service,
     const std::string& extension_id) {
   DCHECK(extensions_service);
 
   // We can't call UninstallExtension with an invalid extension ID, so check it
   // first.
   if (extensions_service->GetExtensionById(extension_id, true)) {
     extensions_service->UninstallExtension(extension_id, false);
   } else {
     LOG(WARNING) << "Attempted uninstallation of non-existent extension with "
       << "id: " << extension_id;
     return false;
   }
 
   return true;
 }
 
-ExtensionsService::ExtensionsService(Profile* profile,
+ExtensionService::ExtensionService(Profile* profile,
                                      const CommandLine* command_line,
                                      const FilePath& install_directory,
                                      ExtensionPrefs* extension_prefs,
                                      bool autoupdate_enabled)
     : profile_(profile),
       extension_prefs_(extension_prefs),
       install_directory_(install_directory),
       extensions_enabled_(true),
       show_extensions_prompts_(true),
       ready_(false),
@@ skipping 22 matching lines @@
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       base::StringToInt(command_line->GetSwitchValueASCII(
           switches::kExtensionsUpdateFrequency),
           &update_frequency);
     }
     updater_ = new ExtensionUpdater(this,
                                     profile->GetPrefs(),
                                     update_frequency);
   }
 
-  backend_ = new ExtensionsServiceBackend(profile->GetPrefs(),
+  backend_ = new ExtensionServiceBackend(profile->GetPrefs(),
                                           install_directory_);
 
   // Use monochrome icons for Omnibox icons.
   omnibox_popup_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_padding(gfx::Insets(0, kOmniboxIconPaddingLeft,
                                                 0, kOmniboxIconPaddingRight));
 }
 
-const ExtensionList* ExtensionsService::extensions() const {
+const ExtensionList* ExtensionService::extensions() const {
   return &extensions_;
 }
 
-const ExtensionList* ExtensionsService::disabled_extensions() const {
+const ExtensionList* ExtensionService::disabled_extensions() const {
   return &disabled_extensions_;
 }
 
-const PendingExtensionMap& ExtensionsService::pending_extensions() const {
+const PendingExtensionMap& ExtensionService::pending_extensions() const {
   return pending_extensions_;
 }
 
-bool ExtensionsService::HasInstalledExtensions() {
+bool ExtensionService::HasInstalledExtensions() {
   return !(extensions_.empty() && disabled_extensions_.empty());
 }
 
-ExtensionsService::~ExtensionsService() {
+ExtensionService::~ExtensionService() {
   DCHECK(!profile_);  // Profile should have told us it's going away.
   UnloadAllExtensions();
   if (updater_.get()) {
     updater_->Stop();
   }
 }
 
-void ExtensionsService::InitEventRouters() {
+void ExtensionService::InitEventRouters() {
   if (event_routers_initialized_)
     return;
 
   ExtensionHistoryEventRouter::GetInstance()->ObserveProfile(profile_);
   ExtensionAccessibilityEventRouter::GetInstance()->ObserveProfile(profile_);
   ExtensionBrowserEventRouter::GetInstance()->Init(profile_);
   ExtensionBookmarkEventRouter::GetInstance()->Observe(
       profile_->GetBookmarkModel());
   ExtensionCookiesEventRouter::GetInstance()->Init();
   ExtensionManagementEventRouter::GetInstance()->Init();
   ExtensionProcessesEventRouter::GetInstance()->ObserveProfile(profile_);
   ExtensionWebNavigationEventRouter::GetInstance()->Init();
   event_routers_initialized_ = true;
 }
 
-const Extension* ExtensionsService::GetExtensionById(const std::string& id,
+const Extension* ExtensionService::GetExtensionById(const std::string& id,
                                                      bool include_disabled) {
   return GetExtensionByIdInternal(id, true, include_disabled);
 }
 
-void ExtensionsService::Init() {
+void ExtensionService::Init() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   // Hack: we need to ensure the ResourceDispatcherHost is ready before we load
   // the first extension, because its members listen for loaded notifications.
   g_browser_process->resource_dispatcher_host();
 
   LoadAllExtensions();
 
   // TODO(erikkay) this should probably be deferred to a future point
   // rather than running immediately at startup.
   CheckForExternalUpdates();
 
   // TODO(erikkay) this should probably be deferred as well.
   GarbageCollectExtensions();
 }
 
-void ExtensionsService::InstallExtension(const FilePath& extension_path) {
+void ExtensionService::InstallExtension(const FilePath& extension_path) {
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(this,  // frontend
                        NULL));  // no client (silent install)
   installer->InstallCrx(extension_path);
 }
 
 namespace {
   // TODO(akalin): Put this somewhere where both crx_installer.cc and
   // this file can use it.
   void DeleteFileHelper(const FilePath& path, bool recursive) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     file_util::Delete(path, recursive);
   }
 }  // namespace
 
-void ExtensionsService::UpdateExtension(const std::string& id,
+void ExtensionService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path,
                                         const GURL& download_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingExtensionMap::const_iterator it = pending_extensions_.find(id);
   bool is_pending_extension = (it != pending_extensions_.end());
 
   const Extension* extension = GetExtensionByIdInternal(id, true, true);
   if (!is_pending_extension && !extension) {
     LOG(WARNING) << "Will not update extension " << id
@@ skipping 18 matching lines @@
   installer->set_expected_id(id);
   if (is_pending_extension)
     installer->set_install_source(it->second.install_source);
   else if (extension)
     installer->set_install_source(extension->location());
   installer->set_delete_source(true);
   installer->set_original_url(download_url);
   installer->InstallCrx(extension_path);
 }
 
-void ExtensionsService::AddPendingExtensionFromSync(
+void ExtensionService::AddPendingExtensionFromSync(
     const std::string& id, const GURL& update_url,
     PendingExtensionInfo::ExpectedCrxType expected_crx_type,
     bool install_silently, bool enable_on_install,
     bool enable_incognito_on_install) {
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add pending extension " << id
                 << " which already exists";
     return;
   }
 
   AddPendingExtensionInternal(id, update_url, expected_crx_type, true,
                               install_silently, enable_on_install,
                               enable_incognito_on_install,
                               Extension::INTERNAL);
 }
 
-void ExtensionsService::AddPendingExtensionFromExternalUpdateUrl(
+void ExtensionService::AddPendingExtensionFromExternalUpdateUrl(
     const std::string& id, const GURL& update_url,
     Extension::Location location) {
   // Add the extension to this list of extensions to update.
   const PendingExtensionInfo::ExpectedCrxType kExpectedCrxType =
       PendingExtensionInfo::UNKNOWN;
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
   const bool kEnableOnInstall = true;
   const bool kEnableIncognitoOnInstall = false;
   if (extension_prefs_->IsExtensionKilled(id))
     return;
 
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add extension " << id
                 << " by external update, but it is already installed.";
     return;
   }
 
   AddPendingExtensionInternal(id, update_url, kExpectedCrxType, kIsFromSync,
                               kInstallSilently, kEnableOnInstall,
                               kEnableIncognitoOnInstall,
                               location);
 }
 
-void ExtensionsService::AddPendingExtensionFromDefaultAppList(
+void ExtensionService::AddPendingExtensionFromDefaultAppList(
     const std::string& id) {
   // Add the extension to this list of extensions to update.
   const PendingExtensionInfo::ExpectedCrxType kExpectedCrxType =
       PendingExtensionInfo::APP;
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
   const bool kEnableOnInstall = true;
   const bool kEnableIncognitoOnInstall = true;
 
   // This can legitimately happen if the user manually installed one of the
   // default apps before this code ran.
   if (GetExtensionByIdInternal(id, true, true))
     return;
 
   AddPendingExtensionInternal(id, GURL(), kExpectedCrxType, kIsFromSync,
                               kInstallSilently, kEnableOnInstall,
                               kEnableIncognitoOnInstall,
                               Extension::INTERNAL);
 }
 
-void ExtensionsService::AddPendingExtensionInternal(
+void ExtensionService::AddPendingExtensionInternal(
     const std::string& id, const GURL& update_url,
     PendingExtensionInfo::ExpectedCrxType expected_crx_type,
     bool is_from_sync, bool install_silently,
     bool enable_on_install, bool enable_incognito_on_install,
     Extension::Location install_source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If a non-sync update is pending, a sync request should not
   // overwrite it.  This is important for external extensions.
   // If an external extension download is pending, and the user has
@@ skipping 11 matching lines @@
     if (!it->second.is_from_sync && is_from_sync)
       return;
   }
 
   pending_extensions_[id] =
       PendingExtensionInfo(update_url, expected_crx_type, is_from_sync,
                            install_silently, enable_on_install,
                            enable_incognito_on_install, install_source);
 }
 
-void ExtensionsService::ReloadExtension(const std::string& extension_id) {
+void ExtensionService::ReloadExtension(const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath path;
   const Extension* current_extension = GetExtensionById(extension_id, false);
 
   // Disable the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
     // later.
     ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
@@ skipping 22 matching lines @@
       installed_extension->extension_manifest.get()) {
     LoadInstalledExtension(*installed_extension, false);
   } else {
     // We should always be able to remember the extension's path. If it's not in
     // the map, someone failed to update |unloaded_extension_paths_|.
     CHECK(!path.empty());
     LoadExtension(path);
   }
 }
 
-void ExtensionsService::UninstallExtension(const std::string& extension_id,
+void ExtensionService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistent extensions.
   CHECK(extension);
 
   // Get hold of information we need after unloading, since the extension
@@ skipping 31 matching lines @@
 
   ClearExtensionData(extension_url);
 
   // Notify interested parties that we've uninstalled this extension.
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_UNINSTALLED,
       Source<Profile>(profile_),
       Details<UninstalledExtensionInfo>(&uninstalled_extension_info));
 }
 
-void ExtensionsService::ClearExtensionData(const GURL& extension_url) {
+void ExtensionService::ClearExtensionData(const GURL& extension_url) {
   scoped_refptr<ExtensionDataDeleter> deleter(
       new ExtensionDataDeleter(profile_, extension_url));
   deleter->StartDeleting();
 }
 
-void ExtensionsService::EnableExtension(const std::string& extension_id) {
+void ExtensionService::EnableExtension(const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, false, true);
   if (!extension)
     return;
 
   extension_prefs_->SetExtensionState(extension, Extension::ENABLED);
 
   // Move it over to the enabled list.
   extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension);
   disabled_extensions_.erase(iter);
 
   // Make sure any browser action contained within it is not hidden.
   extension_prefs_->SetBrowserActionVisibility(extension, true);
 
   ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionLoaded(extension);
   UpdateActiveExtensionsInCrashReporter();
 }
 
-void ExtensionsService::DisableExtension(const std::string& extension_id) {
+void ExtensionService::DisableExtension(const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, true, false);
   // The extension may have been disabled already.
   if (!extension)
     return;
 
   extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
 
   // Move it over to the disabled list.
   disabled_extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(extensions_.begin(),
                                            extensions_.end(),
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionUnloaded(extension);
   UpdateActiveExtensionsInCrashReporter();
 }
 
-void ExtensionsService::GrantPermissions(const Extension* extension) {
+void ExtensionService::GrantPermissions(const Extension* extension) {
   CHECK(extension);
 
   // We only maintain the granted permissions prefs for INTERNAL extensions.
   CHECK(extension->location() == Extension::INTERNAL);
 
   ExtensionExtent effective_hosts = extension->GetEffectiveHostPermissions();
   extension_prefs_->AddGrantedPermissions(extension->id(),
                                           extension->HasFullPermissions(),
                                           extension->api_permissions(),
                                           effective_hosts);
 }
 
-void ExtensionsService::GrantPermissionsAndEnableExtension(
+void ExtensionService::GrantPermissionsAndEnableExtension(
     const Extension* extension) {
   CHECK(extension);
   GrantPermissions(extension);
   extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
   EnableExtension(extension->id());
 }
 
-void ExtensionsService::LoadExtension(const FilePath& extension_path) {
+void ExtensionService::LoadExtension(const FilePath& extension_path) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(),
-          &ExtensionsServiceBackend::LoadSingleExtension,
-          extension_path, scoped_refptr<ExtensionsService>(this)));
+          &ExtensionServiceBackend::LoadSingleExtension,
+          extension_path, scoped_refptr<ExtensionService>(this)));
 }
 
-void ExtensionsService::LoadComponentExtensions() {
+void ExtensionService::LoadComponentExtensions() {
   for (RegisteredComponentExtensions::iterator it =
            component_extension_manifests_.begin();
        it != component_extension_manifests_.end(); ++it) {
     JSONStringValueSerializer serializer(it->manifest);
     scoped_ptr<Value> manifest(serializer.Deserialize(NULL, NULL));
     if (!manifest.get()) {
       DLOG(ERROR) << "Failed to parse manifest for extension";
       continue;
     }
 
     std::string error;
     scoped_refptr<const Extension> extension(Extension::Create(
         it->root_directory,
         Extension::COMPONENT,
         *static_cast<DictionaryValue*>(manifest.get()),
         true,  // require key
         &error));
     if (!extension.get()) {
       NOTREACHED() << error;
       return;
     }
 
     OnExtensionLoaded(extension);
   }
 }
 
-void ExtensionsService::LoadAllExtensions() {
+void ExtensionService::LoadAllExtensions() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Load any component extensions.
   LoadComponentExtensions();
 
   // Load the previously installed extensions.
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
@@ skipping 120 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPackagedApp", packaged_app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExtension", extension_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadUserScript", user_script_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadTheme", theme_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExternal", external_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPageAction", page_action_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadBrowserAction",
                            browser_action_count);
 }
 
-void ExtensionsService::LoadInstalledExtension(const ExtensionInfo& info,
+void ExtensionService::LoadInstalledExtension(const ExtensionInfo& info,
                                                bool write_to_prefs) {
   std::string error;
   scoped_refptr<const Extension> extension(NULL);
   if (!extension_prefs_->IsExtensionAllowedByPolicy(info.extension_id)) {
     error = errors::kDisabledByPolicy;
   } else if (info.extension_manifest.get()) {
     bool require_key = info.extension_location != Extension::LOAD;
     extension = Extension::Create(
         info.extension_path, info.extension_location, *info.extension_manifest,
         require_key, &error);
@@ skipping 12 matching lines @@
   if (write_to_prefs)
     extension_prefs_->UpdateManifest(extension);
 
   OnExtensionLoaded(extension);
 
   if (Extension::IsExternalLocation(info.extension_location)) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(
             backend_.get(),
-            &ExtensionsServiceBackend::CheckExternalUninstall,
-            scoped_refptr<ExtensionsService>(this),
+            &ExtensionServiceBackend::CheckExternalUninstall,
+            scoped_refptr<ExtensionService>(this),
             info.extension_id));
   }
 }
 
-void ExtensionsService::NotifyExtensionLoaded(const Extension* extension) {
+void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
   // The ChromeURLRequestContexts need to be first to know that the extension
   // was loaded, otherwise a race can arise where a renderer that is created
   // for the extension may try to load an extension URL with an extension id
   // that the request context doesn't yet know about. The profile is responsible
   // for ensuring its URLRequestContexts appropriately discover the loaded
   // extension.
   if (profile_) {
     profile_->RegisterExtensionWithRequestContexts(extension);
 
     // Check if this permission requires unlimited storage quota
     if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission))
       GrantUnlimitedStorage(extension);
 
     // If the extension is an app, protect its local storage from
     // "Clear browsing data."
     if (extension->is_app())
       GrantProtectedStorage(extension);
   }
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_LOADED,
       Source<Profile>(profile_),
       Details<const Extension>(extension));
 }
 
-void ExtensionsService::NotifyExtensionUnloaded(const Extension* extension) {
+void ExtensionService::NotifyExtensionUnloaded(const Extension* extension) {
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_UNLOADED,
       Source<Profile>(profile_),
       Details<const Extension>(extension));
 
   if (profile_) {
     profile_->UnregisterExtensionWithRequestContexts(extension);
 
     // Check if this permission required unlimited storage quota, reset its
     // in-memory quota.
     if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission))
       RevokeUnlimitedStorage(extension);
 
     // If this is an app, then stop protecting its storage so it can be deleted.
     if (extension->is_app())
       RevokeProtectedStorage(extension);
   }
 }
 
-void ExtensionsService::GrantProtectedStorage(const Extension* extension) {
+void ExtensionService::GrantProtectedStorage(const Extension* extension) {
   DCHECK(extension->is_app()) << "Only Apps are allowed protected storage.";
   std::vector<GURL> origins;
   GetExplicitOriginsInExtent(extension, &origins);
   for (size_t i = 0; i < origins.size(); ++i)
     ++protected_storage_map_[origins[i]];
 }
 
-void ExtensionsService::RevokeProtectedStorage(const Extension* extension) {
+void ExtensionService::RevokeProtectedStorage(const Extension* extension) {
   DCHECK(extension->is_app()) << "Attempting to revoke protected storage from "
       << " a non-app extension.";
   std::vector<GURL> origins;
   GetExplicitOriginsInExtent(extension, &origins);
   for (size_t i = 0; i < origins.size(); ++i) {
     const GURL& origin = origins[i];
     DCHECK(protected_storage_map_[origin] > 0);
     if (--protected_storage_map_[origin] <= 0)
       protected_storage_map_.erase(origin);
   }
 }
 
-void ExtensionsService::GrantUnlimitedStorage(const Extension* extension) {
+void ExtensionService::GrantUnlimitedStorage(const Extension* extension) {
   DCHECK(extension->HasApiPermission(Extension::kUnlimitedStoragePermission));
   std::vector<GURL> origins;
   GetExplicitOriginsInExtent(extension, &origins);
   origins.push_back(extension->url());
 
   for (size_t i = 0; i < origins.size(); ++i) {
     const GURL& origin = origins[i];
     if (++unlimited_storage_map_[origin] == 1) {
       string16 origin_identifier =
           webkit_database::DatabaseUtil::GetOriginIdentifier(origin);
@@ skipping 14 matching lines @@
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(
               profile_->GetFileSystemContext(),
               &fileapi::SandboxedFileSystemContext::SetOriginQuotaUnlimited,
               origin));
     }
   }
 }
 
-void ExtensionsService::RevokeUnlimitedStorage(const Extension* extension) {
+void ExtensionService::RevokeUnlimitedStorage(const Extension* extension) {
   DCHECK(extension->HasApiPermission(Extension::kUnlimitedStoragePermission));
   std::vector<GURL> origins;
   GetExplicitOriginsInExtent(extension, &origins);
   origins.push_back(extension->url());
 
   for (size_t i = 0; i < origins.size(); ++i) {
     const GURL& origin = origins[i];
     DCHECK(unlimited_storage_map_[origin] > 0);
     if (--unlimited_storage_map_[origin] == 0) {
       unlimited_storage_map_.erase(origin);
@@ skipping 14 matching lines @@
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(
               profile_->GetFileSystemContext(),
               &fileapi::SandboxedFileSystemContext::ResetOriginQuotaUnlimited,
               origin));
     }
   }
 }
 
-void ExtensionsService::UpdateExtensionBlacklist(
+void ExtensionService::UpdateExtensionBlacklist(
   const std::vector<std::string>& blacklist) {
   // Use this set to indicate if an extension in the blacklist has been used.
   std::set<std::string> blacklist_set;
   for (unsigned int i = 0; i < blacklist.size(); ++i) {
     if (Extension::IdIsValid(blacklist[i])) {
       blacklist_set.insert(blacklist[i]);
     }
   }
   extension_prefs_->UpdateBlacklist(blacklist_set);
   std::vector<std::string> to_be_removed;
   // Loop current extensions, unload installed extensions.
   for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (blacklist_set.find(extension->id()) != blacklist_set.end()) {
       to_be_removed.push_back(extension->id());
     }
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (unsigned int i = 0; i < to_be_removed.size(); ++i) {
     UnloadExtension(to_be_removed[i]);
   }
 }
 
-void ExtensionsService::DestroyingProfile() {
+void ExtensionService::DestroyingProfile() {
   pref_change_registrar_.RemoveAll();
   profile_ = NULL;
   toolbar_model_.DestroyingProfile();
 }
 
-ExtensionPrefs* ExtensionsService::extension_prefs() {
+ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
 }
 
-void ExtensionsService::CheckAdminBlacklist() {
+void ExtensionService::CheckAdminBlacklist() {
   std::vector<std::string> to_be_removed;
   // Loop through extensions list, unload installed extensions.
   for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (!extension_prefs_->IsExtensionAllowedByPolicy(extension->id()))
       to_be_removed.push_back(extension->id());
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (unsigned int i = 0; i < to_be_removed.size(); ++i)
     UnloadExtension(to_be_removed[i]);
 }
 
-bool ExtensionsService::IsIncognitoEnabled(const Extension* extension) {
+bool ExtensionService::IsIncognitoEnabled(const Extension* extension) {
   // If this is a component extension we always allow it to work in incognito
   // mode.
   if (extension->location() == Extension::COMPONENT)
     return true;
 
   // Check the prefs.
   return extension_prefs_->IsIncognitoEnabled(extension->id());
 }
 
-void ExtensionsService::SetIsIncognitoEnabled(const Extension* extension,
+void ExtensionService::SetIsIncognitoEnabled(const Extension* extension,
                                               bool enabled) {
   extension_prefs_->SetIsIncognitoEnabled(extension->id(), enabled);
 
   // Broadcast unloaded and loaded events to update browser state. Only bother
   // if the extension is actually enabled, since there is no UI otherwise.
   bool is_enabled = std::find(extensions_.begin(), extensions_.end(),
                               extension) != extensions_.end();
   if (is_enabled) {
     NotifyExtensionUnloaded(extension);
     NotifyExtensionLoaded(extension);
   }
 }
 
-bool ExtensionsService::CanCrossIncognito(const Extension* extension) {
+bool ExtensionService::CanCrossIncognito(const Extension* extension) {
   // We allow the extension to see events and data from another profile iff it
   // uses "spanning" behavior and it has incognito access. "split" mode
   // extensions only see events for a matching profile.
   return IsIncognitoEnabled(extension) && !extension->incognito_split_mode();
 }
 
-bool ExtensionsService::AllowFileAccess(const Extension* extension) {
+bool ExtensionService::AllowFileAccess(const Extension* extension) {
   return (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableExtensionsFileAccessCheck) ||
           extension_prefs_->AllowFileAccess(extension->id()));
 }
 
-void ExtensionsService::SetAllowFileAccess(const Extension* extension,
+void ExtensionService::SetAllowFileAccess(const Extension* extension,
                                            bool allow) {
   extension_prefs_->SetAllowFileAccess(extension->id(), allow);
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_USER_SCRIPTS_UPDATED,
       Source<Profile>(profile_),
       Details<const Extension>(extension));
 }
 
-bool ExtensionsService::GetBrowserActionVisibility(const Extension* extension) {
+bool ExtensionService::GetBrowserActionVisibility(const Extension* extension) {
   return extension_prefs_->GetBrowserActionVisibility(extension);
 }
 
-void ExtensionsService::SetBrowserActionVisibility(const Extension* extension,
+void ExtensionService::SetBrowserActionVisibility(const Extension* extension,
                                                    bool visible) {
   extension_prefs_->SetBrowserActionVisibility(extension, visible);
 }
 
-void ExtensionsService::CheckForExternalUpdates() {
+void ExtensionService::CheckForExternalUpdates() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
-          backend_.get(), &ExtensionsServiceBackend::CheckForExternalUpdates,
-          scoped_refptr<ExtensionsService>(this)));
+          backend_.get(), &ExtensionServiceBackend::CheckForExternalUpdates,
+          scoped_refptr<ExtensionService>(this)));
 }
 
-void ExtensionsService::UpdateExternalPolicyExtensionProvider() {
+void ExtensionService::UpdateExternalPolicyExtensionProvider() {
   const ListValue* list_pref =
       profile_->GetPrefs()->GetList(prefs::kExtensionInstallForceList);
   ListValue* list_copy = NULL;
   if (list_pref)
     list_copy = static_cast<ListValue*>(list_pref->DeepCopy());
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(),
-          &ExtensionsServiceBackend::UpdateExternalPolicyExtensionProvider,
+          &ExtensionServiceBackend::UpdateExternalPolicyExtensionProvider,
           scoped_refptr<RefCountedList>(
               new RefCountedList(list_copy))));
 }
 
-void ExtensionsService::UnloadExtension(const std::string& extension_id) {
+void ExtensionService::UnloadExtension(const std::string& extension_id) {
   // Make sure the extension gets deleted after we return from this function.
   scoped_refptr<const Extension> extension(
       GetExtensionByIdInternal(extension_id, true, true));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension)
     return;
 
   // Keep information about the extension so that we can reload it later
@@ skipping 23 matching lines @@
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   NotifyExtensionUnloaded(extension.get());
   UpdateActiveExtensionsInCrashReporter();
 }
 
-void ExtensionsService::UnloadAllExtensions() {
+void ExtensionService::UnloadAllExtensions() {
   extensions_.clear();
   disabled_extensions_.clear();
   extension_runtime_data_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
-void ExtensionsService::ReloadExtensions() {
+void ExtensionService::ReloadExtensions() {
   UnloadAllExtensions();
   LoadAllExtensions();
 }
 
-void ExtensionsService::GarbageCollectExtensions() {
+void ExtensionService::GarbageCollectExtensions() {
   if (extension_prefs_->pref_service()->ReadOnly())
     return;
 
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
   std::map<std::string, FilePath> extension_paths;
   for (size_t i = 0; i < info->size(); ++i)
     extension_paths[info->at(i)->extension_id] = info->at(i)->extension_path;
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableFunction(
           &extension_file_util::GarbageCollectExtensions, install_directory_,
           extension_paths));
 
   // Also garbage-collect themes.  We check |profile_| to be
   // defensive; in the future, we may call GarbageCollectExtensions()
   // from somewhere other than Init() (e.g., in a timer).
   if (profile_) {
     profile_->GetThemeProvider()->RemoveUnusedThemes();
   }
 }
 
-void ExtensionsService::OnLoadedInstalledExtensions() {
+void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_.get()) {
     updater_->Start();
   }
 
   ready_ = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSIONS_READY,
       Source<Profile>(profile_),
       NotificationService::NoDetails());
 }
 
-void ExtensionsService::OnExtensionLoaded(const Extension* extension) {
+void ExtensionService::OnExtensionLoaded(const Extension* extension) {
   // Ensure extension is deleted unless we transfer ownership.
   scoped_refptr<const Extension> scoped_extension(extension);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
   // If the extension was disabled for a reload, then enable it.
   if (disabled_extension_paths_.erase(extension->id()) > 0)
     EnableExtension(extension->id());
 
@@ skipping 39 matching lines @@
     profile_->GetTemplateURLModel()->RegisterExtensionKeyword(extension);
 
   // Load the icon for omnibox-enabled extensions so it will be ready to display
   // in the URL bar.
   if (!extension->omnibox_keyword().empty()) {
     omnibox_popup_icon_manager_.LoadIcon(extension);
     omnibox_icon_manager_.LoadIcon(extension);
   }
 }
 
-void ExtensionsService::DisableIfPrivilegeIncrease(const Extension* extension) {
+void ExtensionService::DisableIfPrivilegeIncrease(const Extension* extension) {
   // We keep track of all permissions the user has granted each extension.
   // This allows extensions to gracefully support backwards compatibility
   // by including unknown permissions in their manifests. When the user
   // installs the extension, only the recognized permissions are recorded.
   // When the unknown permissions become recognized (e.g., through browser
   // upgrade), we can prompt the user to accept these new permissions.
   // Extensions can also silently upgrade to less permissions, and then
   // silently upgrade to a version that adds these permissions back.
   //
   // For example, pretend that Chrome 10 includes a permission "omnibox"
@@ skipping 61 matching lines @@
   }
 
   // Extension has changed permissions significantly. Disable it. A
   // notification should be sent by the caller.
   if (is_privilege_increase) {
     extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
     extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
   }
 }
 
-void ExtensionsService::UpdateActiveExtensionsInCrashReporter() {
+void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (!extensions_[i]->is_theme() &&
         extensions_[i]->location() != Extension::COMPONENT)
       extension_ids.insert(extensions_[i]->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
-void ExtensionsService::OnExtensionInstalled(const Extension* extension) {
+void ExtensionService::OnExtensionInstalled(const Extension* extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ensure extension is deleted unless we transfer ownership.
   scoped_refptr<const Extension> scoped_extension(extension);
   Extension::State initial_state = Extension::DISABLED;
   bool initial_enable_incognito = false;
   PendingExtensionMap::iterator it =
       pending_extensions_.find(extension->id());
   if (it != pending_extensions_.end()) {
     PendingExtensionInfo pending_extension_info = it->second;
@@ skipping 124 matching lines @@
   if (extension->is_app()) {
     ExtensionIdSet installed_ids = GetAppIds();
     installed_ids.insert(extension->id());
     default_apps_.DidInstallApp(installed_ids);
   }
 
   // Transfer ownership of |extension| to OnExtensionLoaded.
   OnExtensionLoaded(scoped_extension);
 }
 
-const Extension* ExtensionsService::GetExtensionByIdInternal(
+const Extension* ExtensionService::GetExtensionByIdInternal(
     const std::string& id, bool include_enabled, bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     for (ExtensionList::const_iterator iter = extensions_.begin();
         iter != extensions_.end(); ++iter) {
       if ((*iter)->id() == lowercase_id)
         return *iter;
     }
   }
   if (include_disabled) {
     for (ExtensionList::const_iterator iter = disabled_extensions_.begin();
         iter != disabled_extensions_.end(); ++iter) {
       if ((*iter)->id() == lowercase_id)
         return *iter;
     }
   }
   return NULL;
 }
 
-const Extension* ExtensionsService::GetWebStoreApp() {
+const Extension* ExtensionService::GetWebStoreApp() {
   return GetExtensionById(extension_misc::kWebStoreAppId, false);
 }
 
-const Extension* ExtensionsService::GetExtensionByURL(const GURL& url) {
+const Extension* ExtensionService::GetExtensionByURL(const GURL& url) {
   return url.scheme() != chrome::kExtensionScheme ? NULL :
       GetExtensionById(url.host(), false);
 }
 
-const Extension* ExtensionsService::GetExtensionByWebExtent(const GURL& url) {
+const Extension* ExtensionService::GetExtensionByWebExtent(const GURL& url) {
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (extensions_[i]->web_extent().ContainsURL(url))
       return extensions_[i];
   }
   return NULL;
 }
 
-bool ExtensionsService::ExtensionBindingsAllowed(const GURL& url) {
+bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extension.
   if (GetExtensionByURL(url))
     return true;
 
   // Allow bindings for all component, hosted apps.
   const Extension* extension = GetExtensionByWebExtent(url);
   return (extension && extension->location() == Extension::COMPONENT);
 }
 
-const Extension* ExtensionsService::GetExtensionByOverlappingWebExtent(
+const Extension* ExtensionService::GetExtensionByOverlappingWebExtent(
     const ExtensionExtent& extent) {
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (extensions_[i]->web_extent().OverlapsWith(extent))
       return extensions_[i];
   }
 
   return NULL;
 }
 
-const SkBitmap& ExtensionsService::GetOmniboxIcon(
+const SkBitmap& ExtensionService::GetOmniboxIcon(
     const std::string& extension_id) {
   return omnibox_icon_manager_.GetIcon(extension_id);
 }
 
-const SkBitmap& ExtensionsService::GetOmniboxPopupIcon(
+const SkBitmap& ExtensionService::GetOmniboxPopupIcon(
     const std::string& extension_id) {
   return omnibox_popup_icon_manager_.GetIcon(extension_id);
 }
 
-void ExtensionsService::ClearProvidersForTesting() {
+void ExtensionService::ClearProvidersForTesting() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
-          backend_.get(), &ExtensionsServiceBackend::ClearProvidersForTesting));
+          backend_.get(), &ExtensionServiceBackend::ClearProvidersForTesting));
 }
 
-void ExtensionsService::AddProviderForTesting(
+void ExtensionService::AddProviderForTesting(
     ExternalExtensionProvider* test_provider) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
-          backend_.get(), &ExtensionsServiceBackend::AddProviderForTesting,
+          backend_.get(), &ExtensionServiceBackend::AddProviderForTesting,
           test_provider));
 }
 
-void ExtensionsService::OnExternalExtensionFileFound(
+void ExtensionService::OnExternalExtensionFileFound(
          const std::string& id,
          const std::string& version,
          const FilePath& path,
          Extension::Location location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (extension_prefs_->IsExtensionKilled(id))
     return;
 
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get
@@ skipping 32 matching lines @@
       location);
 
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(this,  // frontend
                        NULL));  // no client (silent install)
   installer->set_install_source(location);
   installer->set_expected_id(id);
   installer->InstallCrx(path);
 }
 
-void ExtensionsService::ReportExtensionLoadError(
+void ExtensionService::ReportExtensionLoadError(
     const FilePath& extension_path,
     const std::string &error,
     NotificationType type,
     bool be_noisy) {
   NotificationService* service = NotificationService::current();
   service->Notify(type,
                   Source<Profile>(profile_),
                   Details<const std::string>(&error));
 
   // TODO(port): note that this isn't guaranteed to work properly on Linux.
   std::string path_str = WideToUTF8(extension_path.ToWStringHack());
   std::string message = base::StringPrintf(
       "Could not load extension from '%s'. %s",
       path_str.c_str(), error.c_str());
   ExtensionErrorReporter::GetInstance()->ReportError(message, be_noisy);
 }
 
-void ExtensionsService::DidCreateRenderViewForBackgroundPage(
+void ExtensionService::DidCreateRenderViewForBackgroundPage(
     ExtensionHost* host) {
   OrphanedDevTools::iterator iter =
       orphaned_dev_tools_.find(host->extension()->id());
   if (iter == orphaned_dev_tools_.end())
     return;
 
   DevToolsManager::GetInstance()->AttachClientHost(
       iter->second, host->render_view_host());
   orphaned_dev_tools_.erase(iter);
 }
 
-void ExtensionsService::Observe(NotificationType type,
+void ExtensionService::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_PROCESS_TERMINATED: {
       if (profile_ != Source<Profile>(source).ptr()->GetOriginalProfile())
         break;
 
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
 
       // Unload the entire extension. We want it to be in a consistent state:
       // either fully working or not loaded at all, but never half-crashed.
       // We do it in a PostTask so that other handlers of this notification will
       // still have access to the Extension and ExtensionHost.
       MessageLoop::current()->PostTask(FROM_HERE,
-          NewRunnableMethod(this, &ExtensionsService::UnloadExtension,
+          NewRunnableMethod(this, &ExtensionService::UnloadExtension,
                             host->extension()->id()));
       break;
     }
 
     case NotificationType::PREF_CHANGED: {
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kExtensionInstallAllowList ||
           *pref_name == prefs::kExtensionInstallDenyList) {
         CheckAdminBlacklist();
       } else if (*pref_name == prefs::kExtensionInstallForceList) {
         UpdateExternalPolicyExtensionProvider();
         CheckForExternalUpdates();
         // TODO(gfeher): Also check for external extensions that can be
         // uninstalled because they were removed from the pref.
         // (crbug.com/63667)
       } else {
         NOTREACHED() << "Unexpected preference name.";
       }
       break;
     }
 
     default:
       NOTREACHED() << "Unexpected notification type.";
   }
 }
 
-bool ExtensionsService::HasApps() const {
+bool ExtensionService::HasApps() const {
   return !GetAppIds().empty();
 }
 
-ExtensionIdSet ExtensionsService::GetAppIds() const {
+ExtensionIdSet ExtensionService::GetAppIds() const {
   ExtensionIdSet result;
   for (ExtensionList::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
     if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
 
-bool ExtensionsService::IsBackgroundPageReady(const Extension* extension) {
+bool ExtensionService::IsBackgroundPageReady(const Extension* extension) {
   return (extension->background_url().is_empty() ||
           extension_runtime_data_[extension->id()].background_page_ready);
 }
 
-void ExtensionsService::SetBackgroundPageReady(const Extension* extension) {
+void ExtensionService::SetBackgroundPageReady(const Extension* extension) {
   DCHECK(!extension->background_url().is_empty());
   extension_runtime_data_[extension->id()].background_page_ready = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
       Source<const Extension>(extension),
       NotificationService::NoDetails());
 }
 
-bool ExtensionsService::IsBeingUpgraded(const Extension* extension) {
+bool ExtensionService::IsBeingUpgraded(const Extension* extension) {
   return extension_runtime_data_[extension->id()].being_upgraded;
 }
 
-void ExtensionsService::SetBeingUpgraded(const Extension* extension,
+void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
-PropertyBag* ExtensionsService::GetPropertyBag(const Extension* extension) {
+PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }