Rename ExtensionsService to ExtensionService.

chrome/browser/extensions/extension_browsertest.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/extension_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/test/ui_test_utils.h"
 
@@ skipping 10 matching lines @@
   EnableDOMAutomation();
 
   // This enables it for extension hosts.
   ExtensionHost::EnableDOMAutomation();
 
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
   test_data_dir_ = test_data_dir_.AppendASCII("extensions");
 
 #if defined(OS_CHROMEOS)
   // This makes sure that we create the Default profile first, with no
-  // ExtensionsService and then the real profile with one, as we do when
+  // ExtensionService and then the real profile with one, as we do when
   // running on chromeos.
   command_line->AppendSwitchASCII(switches::kLoginUser,
                                   "TestUser@gmail.com");
   command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
   command_line->AppendSwitch(switches::kNoFirstRun);
 #endif
 }
 
 bool ExtensionBrowserTest::LoadExtensionImpl(const FilePath& path,
                                              bool incognito_enabled) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   {
     NotificationRegistrar registrar;
     registrar.Add(this, NotificationType::EXTENSION_LOADED,
                   NotificationService::AllSources());
     service->LoadExtension(path);
     ui_test_utils::RunMessageLoop();
   }
 
   // Find the extension by iterating backwards since it is likely last.
   FilePath extension_path = path;
@@ skipping 46 matching lines @@
 
   virtual void OnInstallSuccess(const Extension* extension) {}
 
   virtual void OnInstallFailure(const std::string& error) {}
 };
 
 bool ExtensionBrowserTest::InstallOrUpdateExtension(const std::string& id,
                                                     const FilePath& path,
                                                     InstallUIType ui_type,
                                                     int expected_change) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   size_t num_before = service->extensions()->size();
 
   {
     NotificationRegistrar registrar;
     registrar.Add(this, NotificationType::EXTENSION_LOADED,
                   NotificationService::AllSources());
     registrar.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
                   NotificationService::AllSources());
     registrar.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
@@ skipping 29 matching lines @@
          iter != errors->end(); ++iter)
       VLOG(1) << *iter;
 
     return false;
   }
 
   return WaitForExtensionHostsToLoad();
 }
 
 void ExtensionBrowserTest::ReloadExtension(const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->ReloadExtension(extension_id);
   ui_test_utils::RegisterAndWait(this,
                                  NotificationType::EXTENSION_LOADED,
                                  NotificationService::AllSources());
 }
 
 void ExtensionBrowserTest::UnloadExtension(const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->UnloadExtension(extension_id);
 }
 
 void ExtensionBrowserTest::UninstallExtension(const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->UninstallExtension(extension_id, false);
 }
 
 void ExtensionBrowserTest::DisableExtension(const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->DisableExtension(extension_id);
 }
 
 void ExtensionBrowserTest::EnableExtension(const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
   service->EnableExtension(extension_id);
 }
 
 bool ExtensionBrowserTest::WaitForPageActionCountChangeTo(int count) {
   LocationBarTesting* location_bar =
       browser()->window()->GetLocationBar()->GetLocationBarForTesting();
   if (location_bar->PageActionCount() != count) {
     target_page_action_count_ = count;
     ui_test_utils::RegisterAndWait(this,
         NotificationType::EXTENSION_PAGE_ACTION_COUNT_CHANGED,
@@ skipping 54 matching lines @@
 }
 
 void ExtensionBrowserTest::WaitForExtensionLoad() {
   ui_test_utils::RegisterAndWait(this, NotificationType::EXTENSION_LOADED,
                                  NotificationService::AllSources());
   WaitForExtensionHostsToLoad();
 }
 
 bool ExtensionBrowserTest::WaitForExtensionCrash(
     const std::string& extension_id) {
-  ExtensionsService* service = browser()->profile()->GetExtensionsService();
+  ExtensionService* service = browser()->profile()->GetExtensionService();
 
   if (!service->GetExtensionById(extension_id, true)) {
     // The extension is already unloaded, presumably due to a crash.
     return true;
   }
   ui_test_utils::RegisterAndWait(this,
                                  NotificationType::EXTENSION_PROCESS_TERMINATED,
                                  NotificationService::AllSources());
   return (service->GetExtensionById(extension_id, true) == NULL);
 }
@@ skipping 64 matching lines @@
         MessageLoopForUI::current()->Quit();
       }
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }