Rename ExtensionsService to ExtensionService.

chrome/browser/automation/automation_provider.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/automation/automation_provider.h"
 
 #include <set>
 
 #include "app/message_box_flags.h"
 #include "base/callback.h"
@@ skipping 40 matching lines @@
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/save_package.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/importer/importer.h"
 #include "chrome/browser/importer/importer_data_types.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
@@ skipping 229 matching lines @@
   return dl_item_value;
 }
 
 const Extension* AutomationProvider::GetExtension(int extension_handle) {
   return extension_tracker_->GetResource(extension_handle);
 }
 
 const Extension* AutomationProvider::GetEnabledExtension(int extension_handle) {
   const Extension* extension =
       extension_tracker_->GetResource(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service &&
       service->GetExtensionById(extension->id(), false))
     return extension;
   return NULL;
 }
 
 const Extension* AutomationProvider::GetDisabledExtension(
     int extension_handle) {
   const Extension* extension =
       extension_tracker_->GetResource(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service &&
       service->GetExtensionById(extension->id(), true) &&
       !service->GetExtensionById(extension->id(), false))
     return extension;
   return NULL;
 }
 
 void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(AutomationProvider, message)
 #if !defined(OS_MACOSX)
@@ skipping 414 matching lines @@
 
     RenderViewHost* view_host = tab_contents->render_view_host();
     return view_host;
   }
 
   return NULL;
 }
 
 void AutomationProvider::InstallExtension(const FilePath& crx_path,
                                           IPC::Message* reply_message) {
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (service) {
     // The observer will delete itself when done.
     new ExtensionInstallNotificationObserver(this,
                                              AutomationMsg_InstallExtension::ID,
                                              reply_message);
 
     scoped_refptr<CrxInstaller> installer(
         new CrxInstaller(service, NULL));  // silent install, no UI
     installer->InstallCrx(crx_path);
   } else {
     AutomationMsg_InstallExtension::WriteReplyParams(
         reply_message, AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::LoadExpandedExtension(
     const FilePath& extension_dir,
     IPC::Message* reply_message) {
-  if (profile_->GetExtensionsService()) {
+  if (profile_->GetExtensionService()) {
     // The observer will delete itself when done.
     new ExtensionInstallNotificationObserver(
         this,
         AutomationMsg_LoadExpandedExtension::ID,
         reply_message);
 
-    profile_->GetExtensionsService()->LoadExtension(extension_dir);
+    profile_->GetExtensionService()->LoadExtension(extension_dir);
   } else {
     AutomationMsg_LoadExpandedExtension::WriteReplyParams(
         reply_message, AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::GetEnabledExtensions(
     std::vector<FilePath>* result) {
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   DCHECK(service);
   if (service->extensions_enabled()) {
     const ExtensionList* extensions = service->extensions();
     DCHECK(extensions);
     for (size_t i = 0; i < extensions->size(); ++i) {
       const Extension* extension = (*extensions)[i];
       DCHECK(extension);
       if (extension->location() == Extension::INTERNAL ||
           extension->location() == Extension::LOAD) {
         result->push_back(extension->path());
       }
     }
   }
 }
 
 void AutomationProvider::WaitForExtensionTestResult(
     IPC::Message* reply_message) {
   DCHECK(reply_message_ == NULL);
   reply_message_ = reply_message;
   // Call MaybeSendResult, because the result might have come in before
   // we were waiting on it.
   extension_test_result_observer_->MaybeSendResult();
 }
 
 void AutomationProvider::InstallExtensionAndGetHandle(
     const FilePath& crx_path, bool with_ui, IPC::Message* reply_message) {
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
   if (service && manager) {
     // The observer will delete itself when done.
     new ExtensionReadyNotificationObserver(
         manager,
         this,
         AutomationMsg_InstallExtensionAndGetHandle::ID,
         reply_message);
 
     ExtensionInstallUI* client =
         (with_ui ? new ExtensionInstallUI(profile_) : NULL);
     scoped_refptr<CrxInstaller> installer(new CrxInstaller(service, client));
     installer->InstallCrx(crx_path);
   } else {
     AutomationMsg_InstallExtensionAndGetHandle::WriteReplyParams(
         reply_message, 0);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::UninstallExtension(int extension_handle,
                                             bool* success) {
   *success = false;
   const Extension* extension = GetExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service) {
     ExtensionUnloadNotificationObserver observer;
     service->UninstallExtension(extension->id(), false);
     // The extension unload notification should have been sent synchronously
     // with the uninstall. Just to be safe, check that it was received.
     *success = observer.did_receive_unload_notification();
   }
 }
 
 void AutomationProvider::EnableExtension(int extension_handle,
                                          IPC::Message* reply_message) {
   const Extension* extension = GetDisabledExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
   // Only enable if this extension is disabled.
   if (extension && service && manager) {
     // The observer will delete itself when done.
     new ExtensionReadyNotificationObserver(
         manager,
         this,
         AutomationMsg_EnableExtension::ID,
         reply_message);
     service->EnableExtension(extension->id());
   } else {
     AutomationMsg_EnableExtension::WriteReplyParams(reply_message, false);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::DisableExtension(int extension_handle,
                                           bool* success) {
   *success = false;
   const Extension* extension = GetEnabledExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service) {
     ExtensionUnloadNotificationObserver observer;
     service->DisableExtension(extension->id());
     // The extension unload notification should have been sent synchronously
     // with the disable. Just to be safe, check that it was received.
     *success = observer.did_receive_unload_notification();
   }
 }
 
 void AutomationProvider::ExecuteExtensionActionInActiveTabAsync(
     int extension_handle, int browser_handle,
     IPC::Message* reply_message) {
   bool success = false;
   const Extension* extension = GetEnabledExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   ExtensionMessageService* message_service =
       profile_->GetExtensionMessageService();
   Browser* browser = browser_tracker_->GetResource(browser_handle);
   if (extension && service && message_service && browser) {
     int tab_id = ExtensionTabUtil::GetTabId(browser->GetSelectedTabContents());
     if (extension->page_action()) {
       ExtensionBrowserEventRouter::GetInstance()->PageActionExecuted(
           browser->profile(), extension->id(), "action", tab_id, "", 1);
       success = true;
     } else if (extension->browser_action()) {
       ExtensionBrowserEventRouter::GetInstance()->BrowserActionExecuted(
           browser->profile(), extension->id(), browser);
       success = true;
     }
   }
   AutomationMsg_ExecuteExtensionActionInActiveTabAsync::WriteReplyParams(
       reply_message, success);
   Send(reply_message);
 }
 
 void AutomationProvider::MoveExtensionBrowserAction(
     int extension_handle, int index, bool* success) {
   *success = false;
   const Extension* extension = GetEnabledExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service) {
     ExtensionToolbarModel* toolbar = service->toolbar_model();
     if (toolbar) {
       if (index >= 0 && index < static_cast<int>(toolbar->size())) {
         toolbar->MoveBrowserAction(extension, index);
         *success = true;
       } else {
         DLOG(WARNING) << "Attempted to move browser action to invalid index.";
       }
     }
   }
 }
 
 void AutomationProvider::GetExtensionProperty(
     int extension_handle,
     AutomationMsg_ExtensionProperty type,
     bool* success,
     std::string* value) {
   *success = false;
   const Extension* extension = GetExtension(extension_handle);
-  ExtensionsService* service = profile_->GetExtensionsService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (extension && service) {
     ExtensionToolbarModel* toolbar = service->toolbar_model();
     int found_index = -1;
     int index = 0;
     switch (type) {
       case AUTOMATION_MSG_EXTENSION_ID:
         *value = extension->id();
         *success = true;
         break;
       case AUTOMATION_MSG_EXTENSION_NAME:
@@ skipping 29 matching lines @@
     }
   }
 }
 
 void AutomationProvider::SaveAsAsync(int tab_handle) {
   NavigationController* tab = NULL;
   TabContents* tab_contents = GetTabContentsForHandle(tab_handle, &tab);
   if (tab_contents)
     tab_contents->OnSavePage();
 }