Rename ExtensionsService to ExtensionService.

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 33 matching lines @@
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_started_animation.h"
 #include "chrome/browser/extensions/crashed_extension_infobar.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_disabled_infobar_delegate.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/host_zoom_map.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/instant/instant_unload_handler.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/net/browser_url_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/platform_util.h"
@@ skipping 422 matching lines @@
   browser->window()->Show();
 }
 
 // static
 // TODO(erikkay): There are multiple reasons why this could fail.  Should
 // this function return an error reason as well so that callers can show
 // reasonable errors?
 TabContents* Browser::OpenApplication(Profile* profile,
                                       const std::string& app_id,
                                       TabContents* existing_tab) {
-  ExtensionsService* extensions_service = profile->GetExtensionsService();
+  ExtensionService* extensions_service = profile->GetExtensionService();
 
   // If the extension with |app_id| could't be found, most likely because it
   // was uninstalled.
   const Extension* extension =
       extensions_service->GetExtensionById(app_id, false);
   if (!extension)
     return NULL;
 
   return OpenApplication(profile, extension, extension->launch_container(),
                          existing_tab);
@@ skipping 104 matching lines @@
 // static
 TabContents* Browser::OpenApplicationTab(Profile* profile,
                                          const Extension* extension,
                                          TabContents* existing_tab) {
   Browser* browser = BrowserList::GetLastActiveWithProfile(profile);
   TabContents* contents = NULL;
   if (!browser || browser->type() != Browser::TYPE_NORMAL)
     return contents;
 
   // Check the prefs for overridden mode.
-  ExtensionsService* extensions_service = profile->GetExtensionsService();
+  ExtensionService* extensions_service = profile->GetExtensionService();
   DCHECK(extensions_service);
 
   ExtensionPrefs::LaunchType launch_type =
       extensions_service->extension_prefs()->GetLaunchType(
           extension->id(), ExtensionPrefs::LAUNCH_REGULAR);
   UMA_HISTOGRAM_ENUMERATION("Extensions.AppTabLaunchType", launch_type, 100);
   int add_type = TabStripModel::ADD_SELECTED;
   if (launch_type == ExtensionPrefs::LAUNCH_PINNED)
     add_type |= TabStripModel::ADD_PINNED;
 
@@ skipping 2400 matching lines @@
   return window_->GetExtraRenderViewHeight();
 }
 
 void Browser::OnStartDownload(DownloadItem* download, TabContents* tab) {
   if (!window())
     return;
 
 #if defined(OS_CHROMEOS)
   // Don't show content browser for extension/theme downloads from gallery.
   if (download->is_extension_install()) {
-    ExtensionsService* service = profile_->GetExtensionsService();
+    ExtensionService* service = profile_->GetExtensionService();
     if (service && service->IsDownloadFromGallery(download->url(),
                                                   download->referrer_url())) {
       return;
     }
   }
 
   // skip the download shelf and just open the file browser in chromeos
   std::string arg = download->full_path().DirName().value();
   FileBrowseUI::OpenPopup(profile_,
                           arg,
                           FileBrowseUI::kPopupWidth,
                           FileBrowseUI::kPopupHeight);
 
 #else
   // GetDownloadShelf creates the download shelf if it was not yet created.
   window()->GetDownloadShelf()->AddDownload(new DownloadItemModel(download));
 
   // Don't show the animation for "Save file" downloads.
   if (download->total_bytes() <= 0)
     return;
 
   // For non-theme extensions, we don't show the download animation.
   if (download->is_extension_install() &&
-      !ExtensionsService::IsDownloadFromMiniGallery(download->url()))
+      !ExtensionService::IsDownloadFromMiniGallery(download->url()))
     return;
 
   TabContents* current_tab = GetSelectedTabContents();
   // We make this check for the case of minimized windows, unit tests, etc.
   if (platform_util::IsVisible(current_tab->GetNativeView()) &&
       Animation::ShouldRenderRichAnimation()) {
     DownloadStartedAnimation::Show(current_tab);
   }
 #endif
 
@@ skipping 81 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 
   pending_web_app_action_ = NONE;
 }
 
 void Browser::OnInstallApplication(TabContents* source,
                                    const WebApplicationInfo& web_app) {
-  ExtensionsService* extensions_service = profile()->GetExtensionsService();
+  ExtensionService* extensions_service = profile()->GetExtensionService();
   if (!extensions_service)
     return;
 
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(extensions_service,
                        extensions_service->show_extensions_prompts() ?
                        new ExtensionInstallUI(profile()) : NULL));
   installer->InstallWebApp(web_app);
 }
 
@@ skipping 39 matching lines @@
       if (GetSelectedTabContents() &&
           &GetSelectedTabContents()->controller() ==
           Source<NavigationController>(source).ptr())
         UpdateToolbar(false);
       break;
 
     case NotificationType::EXTENSION_UPDATE_DISABLED: {
       // Show the UI if the extension was disabled for escalated permissions.
       Profile* profile = Source<Profile>(source).ptr();
       if (profile_->IsSameProfile(profile)) {
-        ExtensionsService* service = profile->GetExtensionsService();
+        ExtensionService* service = profile->GetExtensionService();
         DCHECK(service);
         const Extension* extension = Details<const Extension>(details).ptr();
         if (service->extension_prefs()->DidExtensionEscalatePermissions(
                 extension->id()))
           ShowExtensionDisabledUI(service, profile_, extension);
       }
       break;
     }
 
     case NotificationType::EXTENSION_UNLOADED:
@@ skipping 13 matching lines @@
 
       break;
     }
 
     case NotificationType::EXTENSION_PROCESS_TERMINATED: {
       window()->GetLocationBar()->InvalidatePageActions();
 
       TabContents* tab_contents = GetSelectedTabContents();
       if (!tab_contents)
         break;
-      ExtensionsService* extensions_service =
-          Source<Profile>(source).ptr()->GetExtensionsService();
+      ExtensionService* extensions_service =
+          Source<Profile>(source).ptr()->GetExtensionService();
       ExtensionHost* extension_host = Details<ExtensionHost>(details).ptr();
       tab_contents->AddInfoBar(new CrashedExtensionInfoBarDelegate(
           tab_contents, extensions_service, extension_host->extension()));
       break;
     }
 
     case NotificationType::EXTENSION_LOADED: {
       window()->GetLocationBar()->UpdatePageActions();
 
       // If any "This extension has crashed" InfoBarDelegates are around for
@@ skipping 26 matching lines @@
       if (BrowserList::FindBrowserWithType(profile(),
                                            Browser::TYPE_NORMAL,
                                            true) != this)
         break;
 
       // We only want to show the loading dialog for themes, but we don't want
       // to wait until unpack to find out an extension is a theme, so we test
       // the download_url GURL instead. This means that themes in the extensions
       // gallery won't get the loading dialog.
       GURL download_url = *(Details<GURL>(details).ptr());
-      if (ExtensionsService::IsDownloadFromMiniGallery(download_url))
+      if (ExtensionService::IsDownloadFromMiniGallery(download_url))
         window()->ShowThemeInstallBubble();
       break;
     }
 
     case NotificationType::PROFILE_ERROR: {
       if (BrowserList::GetLastActive() != this)
         break;
       int* message_id = Details<int>(details).ptr();
       window()->ShowProfileErrorDialog(*message_id);
       break;
@@ skipping 167 matching lines @@
   command_updater_.UpdateCommandEnabled(IDC_HELP_PAGE, true);
   command_updater_.UpdateCommandEnabled(IDC_IMPORT_SETTINGS, true);
 
 #if defined(OS_CHROMEOS)
   command_updater_.UpdateCommandEnabled(IDC_SEARCH, true);
   command_updater_.UpdateCommandEnabled(IDC_SHOW_KEYBOARD_OVERLAY, true);
   command_updater_.UpdateCommandEnabled(IDC_SYSTEM_OPTIONS, true);
   command_updater_.UpdateCommandEnabled(IDC_INTERNET_OPTIONS, true);
 #endif
 
-  ExtensionsService* extensions_service = profile()->GetExtensionsService();
+  ExtensionService* extensions_service = profile()->GetExtensionService();
   bool enable_extensions =
       extensions_service && extensions_service->extensions_enabled();
   command_updater_.UpdateCommandEnabled(IDC_MANAGE_EXTENSIONS,
                                         enable_extensions);
 
   // Initialize other commands based on the window type.
   bool normal_window = type() == TYPE_NORMAL;
   bool non_devtools_window = type() != TYPE_DEVTOOLS;
 
   // Navigation commands
@@ skipping 650 matching lines @@
   return false;
 }
 
 void Browser::CreateInstantIfNecessary() {
   if (type() == TYPE_NORMAL && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(profile_, this));
     instant_unload_handler_.reset(new InstantUnloadHandler(this));
   }
 }