Rename ExtensionsService to ExtensionService.

chrome/browser/extensions/extension_process_manager.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_process_manager.h"
 
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/browsing_instance.h"
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 #include "chrome/browser/extensions/extension_host.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/render_messages.h"
@@ skipping 104 matching lines @@
   host->CreateView(browser);
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateView(const GURL& url,
                                                    Browser* browser,
                                                    ViewType::Type view_type) {
   // A NULL browser may only be given for pop-up views.
   DCHECK(browser || (!browser && view_type == ViewType::EXTENSION_POPUP));
-  ExtensionsService* service =
-      browsing_instance_->profile()->GetExtensionsService();
+  ExtensionService* service =
+      browsing_instance_->profile()->GetExtensionService();
   if (service) {
     const Extension* extension = service->GetExtensionByURL(url);
     if (extension)
       return CreateView(extension, url, browser, view_type);
   }
   return NULL;
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopup(const Extension* extension,
                                                     const GURL& url,
@@ skipping 69 matching lines @@
   // Is it necessary?
   ProcessIDMap::const_iterator it = process_ids_.find(extension_id);
   if (it != process_ids_.end() && (*it).second == process_id)
     return;
 
   // Extension ids should get removed from the map before the process ids get
   // reused from a dead renderer.
   DCHECK(it == process_ids_.end());
   process_ids_[extension_id] = process_id;
 
-  ExtensionsService* extension_service =
-      browsing_instance_->profile()->GetExtensionsService();
+  ExtensionService* extension_service =
+      browsing_instance_->profile()->GetExtensionService();
 
   std::vector<std::string> page_action_ids;
   const Extension* extension =
       extension_service->GetExtensionById(extension_id, false);
   if (extension->page_action())
     page_action_ids.push_back(extension->page_action()->id());
 
   RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
   rph->Send(new ViewMsg_Extension_UpdatePageActions(extension_id,
                                                     page_action_ids));
@@ skipping 33 matching lines @@
 bool ExtensionProcessManager::HasExtensionHost(ExtensionHost* host) const {
   return all_hosts_.find(host) != all_hosts_.end();
 }
 
 void ExtensionProcessManager::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSIONS_READY: {
       CreateBackgroundHosts(this,
-          Source<Profile>(source).ptr()->GetExtensionsService()->extensions());
+          Source<Profile>(source).ptr()->GetExtensionService()->extensions());
       break;
     }
 
     case NotificationType::EXTENSION_LOADED: {
-      ExtensionsService* service =
-          Source<Profile>(source).ptr()->GetExtensionsService();
+      ExtensionService* service =
+          Source<Profile>(source).ptr()->GetExtensionService();
       if (service->is_ready()) {
         const Extension* extension = Details<const Extension>(details).ptr();
         ::CreateBackgroundHost(this, extension);
       }
       break;
     }
 
     case NotificationType::EXTENSION_UNLOADED: {
       const Extension* extension = Details<const Extension>(details).ptr();
       for (ExtensionHostSet::iterator iter = background_hosts_.begin();
@@ skipping 119 matching lines @@
   const Extension* extension = GetExtensionOrAppByURL(url);
   if (!extension || extension->incognito_split_mode()) {
     return ExtensionProcessManager::GetExtensionProcess(url);
   } else {
     return original_manager_->GetExtensionProcess(url);
   }
 }
 
 const Extension* IncognitoExtensionProcessManager::GetExtensionOrAppByURL(
     const GURL& url) {
-  ExtensionsService* service =
-      browsing_instance_->profile()->GetExtensionsService();
+  ExtensionService* service =
+      browsing_instance_->profile()->GetExtensionService();
   if (!service)
     return NULL;
   return (url.SchemeIs(chrome::kExtensionScheme)) ?
       service->GetExtensionByURL(url) : service->GetExtensionByWebExtent(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
-  ExtensionsService* service =
-      browsing_instance_->profile()->GetExtensionsService();
+  ExtensionService* service =
+      browsing_instance_->profile()->GetExtensionService();
   return service && service->IsIncognitoEnabled(extension);
 }
 
 void IncognitoExtensionProcessManager::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::BROWSER_WINDOW_READY: {
       // We want to spawn our background hosts as soon as the user opens an
       // incognito window. Watch for new browsers and create the hosts if
       // it matches our profile.
       Browser* browser = Source<Browser>(source).ptr();
       if (browser->profile() == browsing_instance_->profile()) {
         // On Chrome OS, a login screen is implemented as a browser.
         // This browser has no extension service.  In this case,
         // service will be NULL.
-        ExtensionsService* service =
-            browsing_instance_->profile()->GetExtensionsService();
+        ExtensionService* service =
+            browsing_instance_->profile()->GetExtensionService();
         if (service && service->is_ready())
           CreateBackgroundHosts(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }