Remove GetExtensionService from Profile.

chrome/browser/ui/app_list/extension_app_item.cc

 // Copyright (c) 2012 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/app_list/extension_app_item.h"
 
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/context_menu_matcher.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 45 matching lines @@
 class ExtensionUninstaller : public ExtensionUninstallDialog::Delegate {
  public:
   ExtensionUninstaller(Profile* profile,
                        const std::string& extension_id)
       : profile_(profile),
         extension_id_(extension_id) {
   }
 
   void Run() {
     const Extension* extension =
-        profile_->GetExtensionService()->GetExtensionById(extension_id_, true);
+        extensions::ExtensionSystem::Get(profile_)->extension_service()->
+            GetExtensionById(extension_id_, true);
     if (!extension) {
       CleanUp();
       return;
     }
 
     ExtensionUninstallDialog* dialog =
         ExtensionUninstallDialog::Create(NULL, this);
     dialog->ConfirmUninstall(extension);
   }
 
  private:
   // Overridden from ExtensionUninstallDialog::Delegate:
   virtual void ExtensionUninstallAccepted() OVERRIDE {
-    ExtensionService* service = profile_->GetExtensionService();
+    ExtensionService* service =
+        extensions::ExtensionSystem::Get(profile_)->extension_service();
     const Extension* extension = service->GetExtensionById(extension_id_, true);
     if (extension) {
       service->UninstallExtension(extension_id_,
                                   false, /* external_uninstall*/
                                   NULL);
     }
 
     CleanUp();
   }
 
   virtual void ExtensionUninstallCanceled() OVERRIDE {
     CleanUp();
   }
 
   void CleanUp() {
     delete this;
   }
 
   Profile* profile_;
   std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUninstaller);
 };
 
 extensions::ExtensionPrefs::LaunchType GetExtensionLaunchType(
     Profile* profile,
     const Extension* extension) {
-  return profile->GetExtensionService()->extension_prefs()->GetLaunchType(
-      extension, extensions::ExtensionPrefs::LAUNCH_DEFAULT);
+  return extensions::ExtensionSystem::Get(profile)->extension_service()->
+      extension_prefs()->GetLaunchType(extension,
+          extensions::ExtensionPrefs::LAUNCH_DEFAULT);
 }
 
 void SetExtensionLaunchType(
     Profile* profile,
     const std::string& extension_id,
     extensions::ExtensionPrefs::LaunchType launch_type) {
-  profile->GetExtensionService()->extension_prefs()->SetLaunchType(
-      extension_id, launch_type);
+  extensions::ExtensionSystem::Get(profile)->extension_service()->
+      extension_prefs()->SetLaunchType(extension_id, launch_type);
 }
 
 bool IsExtensionEnabled(Profile* profile, const std::string& extension_id) {
-  ExtensionService* service = profile->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
   return service->IsExtensionEnabled(extension_id) &&
       !service->GetTerminatedExtension(extension_id);
 }
 
 ExtensionSorting* GetExtensionSorting(Profile* profile) {
-  return profile->GetExtensionService()->extension_prefs()->extension_sorting();
+  return extensions::ExtensionSystem::Get(profile)->extension_service()->
+      extension_prefs()->extension_sorting();
 }
 
 bool MenuItemHasLauncherContext(const extensions::MenuItem* item) {
   return item->contexts().Contains(extensions::MenuItem::LAUNCHER);
 }
 
 }  // namespace
 
 ExtensionAppItem::ExtensionAppItem(Profile* profile,
                                    const Extension* extension,
                                    AppListControllerDelegate* controller)
     : ChromeAppListItem(TYPE_APP),
       profile_(profile),
       extension_id_(extension->id()),
       controller_(controller) {
   SetTitle(extension->name());
   LoadImage(extension);
 }
 
 ExtensionAppItem::~ExtensionAppItem() {
 }
 
 const Extension* ExtensionAppItem::GetExtension() const {
-  const Extension* extension =
-      profile_->GetExtensionService()->GetInstalledExtension(extension_id_);
+  const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
+      extension_service()->GetInstalledExtension(extension_id_);
   return extension;
 }
 
 syncer::StringOrdinal ExtensionAppItem::GetPageOrdinal() const {
   return GetExtensionSorting(profile_)->GetPageOrdinal(extension_id_);
 }
 
 syncer::StringOrdinal ExtensionAppItem::GetAppLaunchOrdinal() const {
   return GetExtensionSorting(profile_)->GetAppLaunchOrdinal(extension_id_);
 }
 
 void ExtensionAppItem::Move(const ExtensionAppItem* prev,
                             const ExtensionAppItem* next) {
   // Does nothing if no predecessor nor successor.
   if (!prev && !next)
     return;
 
-  ExtensionService* service = profile_->GetExtensionService();
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   service->extension_prefs()->SetAppDraggedByUser(extension_id_);
 
   // Handles only predecessor or only successor case.
   if (!prev || !next) {
     syncer::StringOrdinal page = prev ? prev->GetPageOrdinal() :
                                         next->GetPageOrdinal();
     GetExtensionSorting(profile_)->SetPageOrdinal(extension_id_, page);
     service->OnExtensionMoved(extension_id_,
                               prev ? prev->extension_id() : std::string(),
                               next ? next->extension_id() : std::string());
@@ skipping 263 matching lines @@
     }
 
     context_menu_model_->AddItemWithStringId(UNINSTALL,
                                              extension->is_platform_app() ?
                                                  IDS_APP_LIST_UNINSTALL_ITEM :
                                                  IDS_EXTENSIONS_UNINSTALL);
   }
 
   return context_menu_model_.get();
 }