Separate the NTP app ordering from the app list app ordering

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 390 matching lines @@
                                       g_browser_process->local_state()));
 
   if (extensions_enabled_) {
     extensions::ExternalProviderImpl::CreateExternalProviders(
         this, profile_, &external_extension_providers_);
   }
 
   // Set this as the ExtensionService for extension sorting to ensure it
   // cause syncs if required.
   extension_prefs_->extension_sorting()->SetExtensionService(this);
+  extension_prefs_->app_list_extension_sorting()->SetExtensionService(this);
 
   is_first_run_ = !extension_prefs_->SetAlertSystemFirstRun();
 
 #if defined(ENABLE_EXTENSIONS)
   extension_action_storage_manager_.reset(
       new extensions::ExtensionActionStorageManager(profile_));
 #endif
 
   // How long is the path to the Extensions directory?
   UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.ExtensionRootPathLength",
@@ skipping 876 matching lines @@
     syncer::ModelType type = i->sync_data().GetDataType();
     if (type == syncer::EXTENSIONS) {
       extension_sync_bundle_.ProcessSyncChange(
           extensions::ExtensionSyncData(*i));
     } else if (type == syncer::APPS) {
       app_sync_bundle_.ProcessSyncChange(extensions::AppSyncData(*i));
     }
   }
 
   extension_prefs()->extension_sorting()->FixNTPOrdinalCollisions();
+  extension_prefs()->app_list_extension_sorting()->FixSyncCollisions();
 
   return syncer::SyncError();
 }
 
 extensions::ExtensionSyncData ExtensionService::GetExtensionSyncData(
     const Extension& extension) const {
   return extensions::ExtensionSyncData(extension,
                                        IsExtensionEnabled(extension.id()),
                                        IsIncognitoEnabled(extension.id()));
 }
 
 extensions::AppSyncData ExtensionService::GetAppSyncData(
     const Extension& extension) const {
   return extensions::AppSyncData(
       extension,
       IsExtensionEnabled(extension.id()),
       IsIncognitoEnabled(extension.id()),
       extension_prefs_->extension_sorting()->GetAppLaunchOrdinal(
           extension.id()),
-      extension_prefs_->extension_sorting()->GetPageOrdinal(extension.id()));
+      extension_prefs_->extension_sorting()->GetPageOrdinal(extension.id()),
+      extension_prefs_->app_list_extension_sorting()->
+          GetAppListOrdinalFromPrefs(extension.id()));
 }
 
 std::vector<extensions::ExtensionSyncData>
   ExtensionService::GetExtensionSyncDataList() const {
   std::vector<extensions::ExtensionSyncData> extension_sync_list;
   extension_sync_bundle_.GetExtensionSyncDataListHelper(extensions_,
                                                         &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(disabled_extensions_,
                                                         &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(terminated_extensions_,
@@ skipping 45 matching lines @@
 
   if (app_sync_data.app_launch_ordinal().IsValid() &&
       app_sync_data.page_ordinal().IsValid()) {
     extension_prefs_->extension_sorting()->SetAppLaunchOrdinal(
         id,
         app_sync_data.app_launch_ordinal());
     extension_prefs_->extension_sorting()->SetPageOrdinal(
         id,
         app_sync_data.page_ordinal());
   }
+  if (app_sync_data.app_list_ordinal().IsValid()) {
+    extension_prefs_->app_list_extension_sorting()->
+        UpdateAppListOrdinalFromSync(id, app_sync_data.app_list_ordinal());
+  }
 
   if (!ProcessExtensionSyncDataHelper(app_sync_data.extension_sync_data(),
                                       syncer::APPS)) {
     app_sync_bundle_.AddPendingApp(id, app_sync_data);
     CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
@@ skipping 626 matching lines @@
   } else {
     // All apps that are displayed in the launcher are ordered by their ordinals
     // so we must ensure they have valid ordinals.
     if (extension->RequiresSortOrdinal()) {
       if (!extension->ShouldDisplayInNewTabPage()) {
         extension_prefs_->extension_sorting()->MarkExtensionAsHidden(
             extension->id());
       }
       extension_prefs_->extension_sorting()->EnsureValidOrdinals(
           extension->id(), syncer::StringOrdinal());
+      AppListExtensionSorting* ordering =
+          extension_prefs_->app_list_extension_sorting();
+      if (!ordering->Contains(extension->id()))
+        ordering->InsertAtBack(extension->id());
     }
 
     extensions_.Insert(extension);
     SyncExtensionChangeIfNeeded(*extension);
     NotifyExtensionLoaded(extension);
   }
   SetBeingUpgraded(extension, false);
 }
 
 void ExtensionService::AddComponentExtension(const Extension* extension) {
@@ skipping 987 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }