Remove ExtensionService::extension_prefs()

chrome/browser/sync/test/integration/sync_app_helper.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/sync/test/integration/sync_app_helper.h"
 
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/test/integration/extensions_helper.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_extension_helper.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/sync_helper.h"
 #include "extensions/browser/app_sorting.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/id_util.h"
 
+using extensions::ExtensionPrefs;
+
 namespace {
 
 struct AppState {
   AppState();
   ~AppState();
   bool IsValid() const;
   bool Equals(const AppState& other) const;
 
   syncer::StringOrdinal app_launch_ordinal;
   syncer::StringOrdinal page_ordinal;
@@ skipping 10 matching lines @@
   return page_ordinal.IsValid() && app_launch_ordinal.IsValid();
 }
 
 bool AppState::Equals(const AppState& other) const {
   return app_launch_ordinal.Equals(other.app_launch_ordinal) &&
       page_ordinal.Equals(other.page_ordinal) &&
       launch_type == other.launch_type;
 }
 
 // Load all the app specific values for |id| into |app_state|.
-void LoadApp(ExtensionService* extension_service,
+void LoadApp(content::BrowserContext* context,

[James Cook, 2014/02/07 00:53:02]

Nice cleanup.

              const std::string& id,
              AppState* app_state) {
-  app_state->app_launch_ordinal = extension_service->extension_prefs()->
-      app_sorting()->GetAppLaunchOrdinal(id);
-  app_state->page_ordinal = extension_service->extension_prefs()->
-      app_sorting()->GetPageOrdinal(id);
-  app_state->launch_type =
-      extensions::GetLaunchTypePrefValue(extension_service->extension_prefs(),
-                                         id);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
+  app_state->app_launch_ordinal = prefs->app_sorting()->GetAppLaunchOrdinal(id);
+  app_state->page_ordinal = prefs->app_sorting()->GetPageOrdinal(id);
+  app_state->launch_type = extensions::GetLaunchTypePrefValue(prefs, id);
 }
 
 // Returns a map from |profile|'s installed extensions to their state.
 AppStateMap GetAppStates(Profile* profile) {
   AppStateMap app_state_map;
 
   ExtensionService* extension_service = profile->GetExtensionService();
 
   scoped_ptr<const extensions::ExtensionSet> extensions(
       extension_service->GenerateInstalledExtensionsSet());
   for (extensions::ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     if (extensions::sync_helper::IsSyncableApp(it->get())) {
       const std::string& id = (*it)->id();
-      LoadApp(extension_service, id, &(app_state_map[id]));
+      LoadApp(profile, id, &(app_state_map[id]));
     }
   }
 
   const extensions::PendingExtensionManager* pending_extension_manager =
       extension_service->pending_extension_manager();
 
   std::list<std::string> pending_crx_ids;
   pending_extension_manager->GetPendingIdsForUpdateCheck(&pending_crx_ids);
 
   for (std::list<std::string>::const_iterator id = pending_crx_ids.begin();
        id != pending_crx_ids.end(); ++id) {
-    LoadApp(extension_service, *id, &(app_state_map[*id]));
+    LoadApp(profile, *id, &(app_state_map[*id]));
   }
 
   return app_state_map;
 }
 
 }  // namespace
 
 SyncAppHelper* SyncAppHelper::GetInstance() {
   SyncAppHelper* instance = Singleton<SyncAppHelper>::get();
   instance->SetupIfNecessary(sync_datatype_helper::test());
@@ skipping 50 matching lines @@
     ++it1;
     ++it2;
   }
 
   return true;
 }
 
 syncer::StringOrdinal SyncAppHelper::GetPageOrdinalForApp(
     Profile* profile,
     const std::string& name) {
-  return profile->GetExtensionService()->extension_prefs()->
-      app_sorting()->GetPageOrdinal(extensions::id_util::GenerateId(name));
+  return ExtensionPrefs::Get(profile)->app_sorting()->
+      GetPageOrdinal(extensions::id_util::GenerateId(name));
 }
 
 void SyncAppHelper::SetPageOrdinalForApp(
     Profile* profile,
     const std::string& name,
     const syncer::StringOrdinal& page_ordinal) {
-  profile->GetExtensionService()->extension_prefs()->app_sorting()->
+  ExtensionPrefs::Get(profile)->app_sorting()->
       SetPageOrdinal(extensions::id_util::GenerateId(name), page_ordinal);
 }
 
 syncer::StringOrdinal SyncAppHelper::GetAppLaunchOrdinalForApp(
     Profile* profile,
     const std::string& name) {
-  return profile->GetExtensionService()->extension_prefs()->
-      app_sorting()->GetAppLaunchOrdinal(extensions::id_util::GenerateId(name));
+  return ExtensionPrefs::Get(profile)->app_sorting()->
+      GetAppLaunchOrdinal(extensions::id_util::GenerateId(name));
 }
 
 void SyncAppHelper::SetAppLaunchOrdinalForApp(
     Profile* profile,
     const std::string& name,
     const syncer::StringOrdinal& app_launch_ordinal) {
-  profile->GetExtensionService()->extension_prefs()->app_sorting()->
-      SetAppLaunchOrdinal(extensions::id_util::GenerateId(name),
-                          app_launch_ordinal);
+  ExtensionPrefs::Get(profile)->app_sorting()->SetAppLaunchOrdinal(
+      extensions::id_util::GenerateId(name), app_launch_ordinal);
 }
 
 void SyncAppHelper::FixNTPOrdinalCollisions(Profile* profile) {
-  profile->GetExtensionService()->extension_prefs()->app_sorting()->
-      FixNTPOrdinalCollisions();
+  ExtensionPrefs::Get(profile)->app_sorting()->FixNTPOrdinalCollisions();
 }
 
 SyncAppHelper::SyncAppHelper() : setup_completed_(false) {}
 
 SyncAppHelper::~SyncAppHelper() {}