Move ownership of AppSorting from ExtensionPrefs to ExtensionSystem

chrome/browser/extensions/extension_sync_service.cc

 // Copyright 2013 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_sync_service.h"
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/extensions/bookmark_app_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_sync_service_factory.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/sync_start_util.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/sync_helper.h"
 #include "chrome/common/web_application_info.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/image_util.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 
+using extensions::AppSorting;
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::ExtensionSyncData;
+using extensions::ExtensionSystem;
 using extensions::SyncBundle;
 
 namespace {
 
 void OnWebApplicationInfoLoaded(
     WebApplicationInfo synced_info,
     base::WeakPtr<ExtensionService> extension_service,
     const WebApplicationInfo& loaded_info) {
   DCHECK_EQ(synced_info.app_url, loaded_info.app_url);
 
@@ skipping 53 matching lines @@
 
 ExtensionSyncService::~ExtensionSyncService() {}
 
 // static
 ExtensionSyncService* ExtensionSyncService::Get(
     content::BrowserContext* context) {
   return ExtensionSyncServiceFactory::GetForBrowserContext(context);
 }
 
 void ExtensionSyncService::SyncUninstallExtension(
-    const extensions::Extension& extension) {
+    const Extension& extension) {
   if (!extensions::util::ShouldSync(&extension, profile_))
     return;
 
   // TODO(tim): If we get here and IsSyncing is false, this will cause
   // "back from the dead" style bugs, because sync will add-back the extension
   // that was uninstalled here when MergeDataAndStartSyncing is called.
   // See crbug.com/256795.
   syncer::ModelType type =
       extension.is_app() ? syncer::APPS : syncer::EXTENSIONS;
   SyncBundle* bundle = GetSyncBundle(type);
@@ skipping 52 matching lines @@
   // Now push those local changes to sync.
   // TODO(treib,kalman): We should only have to send out changes for extensions
   // which have NeedsSync set (i.e. |GetLocalSyncDataList(type, false)|). That
   // makes some sync_integration_tests fail though - figure out why and fix it!
   std::vector<ExtensionSyncData> data_list = GetLocalSyncDataList(type, true);
   bundle->PushSyncDataList(ToSyncerSyncDataList(data_list));
   for (const ExtensionSyncData& data : data_list)
     ExtensionPrefs::Get(profile_)->SetNeedsSync(data.id(), false);
 
   if (type == syncer::APPS)
-    extension_prefs_->app_sorting()->FixNTPOrdinalCollisions();
+    ExtensionSystem::Get(profile_)->app_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncMergeResult(type);
 }
 
 void ExtensionSyncService::StopSyncing(syncer::ModelType type) {
   GetSyncBundle(type)->Reset();
 }
 
 syncer::SyncDataList ExtensionSyncService::GetAllSyncData(
     syncer::ModelType type) const {
   const SyncBundle* bundle = GetSyncBundle(type);
   if (!bundle->IsSyncing())
     return syncer::SyncDataList();
 
-  std::vector<extensions::ExtensionSyncData> sync_data_list =
+  std::vector<ExtensionSyncData> sync_data_list =
       GetLocalSyncDataList(type, true);
 
   // Add pending data (where the local extension is either not installed yet or
   // outdated).
   std::vector<ExtensionSyncData> pending_extensions = bundle->GetPendingData();
   sync_data_list.insert(sync_data_list.begin(),
                         pending_extensions.begin(),
                         pending_extensions.end());
 
   return ToSyncerSyncDataList(sync_data_list);
 }
 
 syncer::SyncError ExtensionSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   for (const syncer::SyncChange& sync_change : change_list) {
     scoped_ptr<ExtensionSyncData> extension_sync_data(
         ExtensionSyncData::CreateFromSyncChange(sync_change));
     if (extension_sync_data)
       ApplySyncData(*extension_sync_data);
   }
 
-  extension_prefs_->app_sorting()->FixNTPOrdinalCollisions();
+  ExtensionSystem::Get(profile_)->app_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
 ExtensionSyncData ExtensionSyncService::CreateSyncData(
-    const extensions::Extension& extension) const {
+    const Extension& extension) const {
   bool enabled = extension_service_->IsExtensionEnabled(extension.id());
   int disable_reasons = extension_prefs_->GetDisableReasons(extension.id());
   bool incognito_enabled = extensions::util::IsIncognitoEnabled(extension.id(),
                                                                 profile_);
   bool remote_install =
       extension_prefs_->HasDisableReason(extension.id(),
                                          Extension::DISABLE_REMOTE_INSTALL);
   ExtensionSyncData::OptionalBoolean allowed_on_all_url =
       GetAllowedOnAllUrlsOptionalBoolean(extension.id(), profile_);
   if (extension.is_app()) {
+    AppSorting* app_sorting = ExtensionSystem::Get(profile_)->app_sorting();
     return ExtensionSyncData(
         extension, enabled, disable_reasons, incognito_enabled, remote_install,
         allowed_on_all_url,
-        extension_prefs_->app_sorting()->GetAppLaunchOrdinal(extension.id()),
-        extension_prefs_->app_sorting()->GetPageOrdinal(extension.id()),
+        app_sorting->GetAppLaunchOrdinal(extension.id()),
+        app_sorting->GetPageOrdinal(extension.id()),
         extensions::GetLaunchTypePrefValue(extension_prefs_, extension.id()));
   }
   return ExtensionSyncData(
       extension, enabled, disable_reasons, incognito_enabled, remote_install,
       allowed_on_all_url);
 }
 
 bool ExtensionSyncService::ApplySyncData(
     const ExtensionSyncData& extension_sync_data) {
   syncer::ModelType type = extension_sync_data.is_app() ? syncer::APPS
                                                         : syncer::EXTENSIONS;
   SyncBundle* bundle = GetSyncBundle(type);
   bundle->ApplySyncData(extension_sync_data);
 
   const std::string& id = extension_sync_data.id();
 
   if (extension_sync_data.is_app()) {
     if (extension_sync_data.app_launch_ordinal().IsValid() &&
         extension_sync_data.page_ordinal().IsValid()) {
-      extension_prefs_->app_sorting()->SetAppLaunchOrdinal(
+      AppSorting* app_sorting = ExtensionSystem::Get(profile_)->app_sorting();
+      app_sorting->SetAppLaunchOrdinal(
           id,
           extension_sync_data.app_launch_ordinal());
-      extension_prefs_->app_sorting()->SetPageOrdinal(
-          id,
-          extension_sync_data.page_ordinal());
+      app_sorting->SetPageOrdinal(id, extension_sync_data.page_ordinal());
     }
 
     // The corresponding validation of this value during ExtensionSyncData
     // population is in ExtensionSyncData::ToAppSpecifics.
     if (extension_sync_data.launch_type() >= extensions::LAUNCH_TYPE_FIRST &&
         extension_sync_data.launch_type() < extensions::NUM_LAUNCH_TYPES) {
       extensions::SetLaunchType(
           profile_, id, extension_sync_data.launch_type());
     }
 
     if (!extension_sync_data.bookmark_app_url().empty())
       ApplyBookmarkAppSyncData(extension_sync_data);
   }
 
   if (!ApplyExtensionSyncDataHelper(extension_sync_data, type)) {
     bundle->AddPendingExtension(id, extension_sync_data);
     extension_service_->CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
 
 void ExtensionSyncService::ApplyBookmarkAppSyncData(
-    const extensions::ExtensionSyncData& extension_sync_data) {
+    const ExtensionSyncData& extension_sync_data) {
   DCHECK(extension_sync_data.is_app());
 
   // Process bookmark app sync if necessary.
   GURL bookmark_app_url(extension_sync_data.bookmark_app_url());
   if (!bookmark_app_url.is_valid() ||
       extension_sync_data.uninstalled()) {
     return;
   }
 
   const Extension* extension =
@@ skipping 206 matching lines @@
       // non-INTERNAL location.  Add to pending_sync_data, even though it will
       // never be removed (we'll never install a syncable version of the
       // extension), so that GetAllSyncData() continues to send it.
     }
     // Track pending extensions so that we can return them in GetAllSyncData().
     return false;
   }
 
   return true;
 }