Remove Ordinals Setters and Getters from ExtensionService

chrome/browser/extensions/extension_service.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/extensions/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 427 matching lines @@
           this, profile_, &external_extension_providers_);
     }
   }
 
   // Use monochrome icons for Omnibox icons.
   omnibox_popup_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_padding(gfx::Insets(0, kOmniboxIconPaddingLeft,
                                                 0, kOmniboxIconPaddingRight));
 
+  // Set this as the ExtensionService for extension sorting to ensure it
+  // cause syncs if required.
+  extension_prefs_->extension_sorting()->SetExtensionService(this);
+
   // How long is the path to the Extensions directory?
   UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.ExtensionRootPathLength",
                               install_directory_.value().length(), 0, 500, 100);
 }
 
 const ExtensionSet* ExtensionService::extensions() const {
   return &extensions_;
 }
 
 const ExtensionSet* ExtensionService::disabled_extensions() const {
@@ skipping 309 matching lines @@
   SyncBundle* sync_bundle = GetSyncBundleForExtension(*extension);
 
   SyncChange sync_change;
   if (sync_bundle) {
     ExtensionSyncData extension_sync_data(
         *extension,
         IsExtensionEnabled(extension_id),
         IsIncognitoEnabled(extension_id),
         extension_prefs_->GetAppNotificationClientId(extension_id),
         extension_prefs_->IsAppNotificationDisabled(extension_id),
-        GetAppLaunchOrdinal(extension_id),
-        GetPageOrdinal(extension_id));
+        extension_prefs_->extension_sorting()->
+            GetAppLaunchOrdinal(extension_id),
+        extension_prefs_->extension_sorting()->GetPageOrdinal(extension_id));
     sync_change = extension_sync_data.GetSyncChange(SyncChange::ACTION_DELETE);
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UninstallType",
                             extension->GetType(), 100);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_Uninstall");
 
   TemplateURLService* url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
@@ skipping 478 matching lines @@
 
 bool ExtensionService::SyncBundle::HasExtensionId(const std::string& id) const {
   return synced_extensions.find(id) != synced_extensions.end();
 }
 
 bool ExtensionService::SyncBundle::HasPendingExtensionId(const std::string& id)
     const {
   return pending_sync_data.find(id) != pending_sync_data.end();
 }
 
-void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
-  SyncBundle* sync_bundle = GetSyncBundleForExtension(extension);
-  if (sync_bundle) {
-    ExtensionSyncData extension_sync_data(
-        extension,
-        IsExtensionEnabled(extension.id()),
-        IsIncognitoEnabled(extension.id()),
-        extension_prefs_->GetAppNotificationClientId(extension.id()),
-        extension_prefs_->IsAppNotificationDisabled(extension.id()),
-        GetAppLaunchOrdinal(extension.id()),
-        GetPageOrdinal(extension.id()));
-
-    SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
-        sync_bundle->HasExtensionId(extension.id()) ?
-            SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD));
-    sync_bundle->sync_processor->ProcessSyncChanges(
-        FROM_HERE, sync_change_list);
-    sync_bundle->synced_extensions.insert(extension.id());
-    sync_bundle->pending_sync_data.erase(extension.id());
-  }
-}
-
 ExtensionService::SyncBundle* ExtensionService::GetSyncBundleForExtension(
     const Extension& extension) {
   if (app_sync_bundle_.filter(extension))
     return &app_sync_bundle_;
   else if (extension_sync_bundle_.filter(extension))
     return &extension_sync_bundle_;
   else
     return NULL;
 }
 
@@ skipping 144 matching lines @@
         // If we have pending extension data for this extension, then this
         // version is out of date.  We'll sync back the version we got from
         // sync.
         !bundle.HasPendingExtensionId(extension.id())) {
       sync_data_list->push_back(ExtensionSyncData(
           extension,
           IsExtensionEnabled(extension.id()),
           IsIncognitoEnabled(extension.id()),
           extension_prefs_->GetAppNotificationClientId(extension.id()),
           extension_prefs_->IsAppNotificationDisabled(extension.id()),
-          GetAppLaunchOrdinal(extension.id()),
-          GetPageOrdinal(extension.id())));
+          extension_prefs_->extension_sorting()->
+              GetAppLaunchOrdinal(extension.id()),
+          extension_prefs_->extension_sorting()->
+              GetPageOrdinal(extension.id())));
     }
   }
 }
 
 std::vector<ExtensionSyncData> ExtensionService::GetSyncDataList(
     const SyncBundle& bundle) const {
   std::vector<ExtensionSyncData> extension_sync_list;
   GetSyncDataListHelper(extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(disabled_extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(terminated_extensions_, bundle, &extension_sync_list);
@@ skipping 41 matching lines @@
   // incognito flag invalidates the |extension| pointer (it reloads the
   // extension).
   bool extension_installed = (extension != NULL);
   int result = extension ?
       extension->version()->CompareTo(extension_sync_data.version()) : 0;
   SetIsIncognitoEnabled(id, extension_sync_data.incognito_enabled());
   extension = NULL;  // No longer safe to use.
 
   if (extension_sync_data.app_launch_ordinal().IsValid() &&
       extension_sync_data.page_ordinal().IsValid()) {
-    SetAppLaunchOrdinal(id, extension_sync_data.app_launch_ordinal());
-    SetPageOrdinal(id, extension_sync_data.page_ordinal());
+    extension_prefs_->extension_sorting()->SetAppLaunchOrdinal(
+        id,
+        extension_sync_data.app_launch_ordinal());
+    extension_prefs_->extension_sorting()->SetPageOrdinal(
+        id,
+        extension_sync_data.page_ordinal());
   }
 
   if (extension_installed) {
     // If the extension is already installed, check if it's outdated.
     if (result < 0) {
       // Extension is outdated.
       bundle.pending_sync_data[extension_sync_data.id()] = extension_sync_data;
       CheckForUpdatesSoon();
     }
     if (extension_sync_data.type() == Extension::SYNC_TYPE_APP &&
@@ skipping 115 matching lines @@
 
 bool ExtensionService::CanLoadInIncognito(const Extension* extension) const {
   if (extension->is_hosted_app())
     return true;
   // Packaged apps and regular extensions need to be enabled specifically for
   // incognito (and split mode should be set).
   return extension->incognito_split_mode() &&
          IsIncognitoEnabled(extension->id());
 }
 
-StringOrdinal ExtensionService::GetAppLaunchOrdinal(
-    const std::string& extension_id) const {
-  return
-      extension_prefs_->extension_sorting()->GetAppLaunchOrdinal(extension_id);
-}
-
-void ExtensionService::SetAppLaunchOrdinal(
-    const std::string& extension_id,
-    const StringOrdinal& app_launch_ordinal) {
-  // Only apps should set this value, so we check that it is either an app or
-  // that it is not yet installed (so we can't be sure it is an app). It is
-  // possible to be setting this value through syncing before the app is
-  // installed.
-  const Extension* ext = GetExtensionById(extension_id, true);
-  DCHECK(!ext || ext->is_app());
-
-  extension_prefs_->extension_sorting()->SetAppLaunchOrdinal(
-      extension_id, app_launch_ordinal);
-
-  const Extension* extension = GetInstalledExtension(extension_id);
-  if (extension)
-    SyncExtensionChangeIfNeeded(*extension);
-}
-
-StringOrdinal ExtensionService::GetPageOrdinal(
-    const std::string& extension_id) const {
-  return extension_prefs_->extension_sorting()->GetPageOrdinal(extension_id);
-}
-
-void ExtensionService::SetPageOrdinal(const std::string& extension_id,
-                                      const StringOrdinal& page_ordinal) {
-  // Only apps should set this value, so we check that it is either an app or
-  // that it is not yet installed (so we can't be sure it is an app). It is
-  // possible to be setting this value through syncing before the app is
-  // installed.
-  const Extension* ext = GetExtensionById(extension_id, true);
-  DCHECK(!ext || ext->is_app());
-
-  extension_prefs_->extension_sorting()->SetPageOrdinal(
-      extension_id, page_ordinal);
-
-  const Extension* extension = GetInstalledExtension(extension_id);
-  if (extension)
-    SyncExtensionChangeIfNeeded(*extension);
-}
-
 void ExtensionService::OnExtensionMoved(
     const std::string& moved_extension_id,
     const std::string& predecessor_extension_id,
     const std::string& successor_extension_id) {
   extension_prefs_->extension_sorting()->OnExtensionMoved(
       moved_extension_id,
       predecessor_extension_id,
       successor_extension_id);
 
   const Extension* extension = GetInstalledExtension(moved_extension_id);
@@ skipping 285 matching lines @@
     NOTREACHED();
 
   // Also garbage-collect themes.  We check |profile_| to be
   // defensive; in the future, we may call GarbageCollectExtensions()
   // from somewhere other than Init() (e.g., in a timer).
   if (profile_) {
     ThemeServiceFactory::GetForProfile(profile_)->RemoveUnusedThemes();
   }
 }
 
+void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
+  SyncBundle* sync_bundle = GetSyncBundleForExtension(extension);
+  if (sync_bundle) {
+    ExtensionSyncData extension_sync_data(
+        extension,
+        IsExtensionEnabled(extension.id()),
+        IsIncognitoEnabled(extension.id()),
+        extension_prefs_->GetAppNotificationClientId(extension.id()),
+        extension_prefs_->IsAppNotificationDisabled(extension.id()),
+        extension_prefs_->extension_sorting()->
+            GetAppLaunchOrdinal(extension.id()),
+        extension_prefs_->extension_sorting()->GetPageOrdinal(extension.id()));
+
+    SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
+        sync_bundle->HasExtensionId(extension.id()) ?
+            SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD));
+    sync_bundle->sync_processor->ProcessSyncChanges(
+        FROM_HERE, sync_change_list);
+    sync_bundle->synced_extensions.insert(extension.id());
+    sync_bundle->pending_sync_data.erase(extension.id());
+  }
+}
+
 void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_.get()) {
     updater_->Start();
   }
 
   ready_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSIONS_READY,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
@@ skipping 644 matching lines @@
   return api_resource_controller_;
 }
 
 extensions::RulesRegistryService* ExtensionService::GetRulesRegistryService() {
   if (!rules_registry_service_.get()) {
     rules_registry_service_.reset(
         new extensions::RulesRegistryService(profile_));
   }
   return rules_registry_service_.get();
 }