Separate the NTP app ordering from the app list app ordering

chrome/browser/ui/app_list/apps_model_builder_unittest.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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/ui/app_list/apps_model_builder.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
-#include "chrome/browser/extensions/extension_sorting.h"
+#include "chrome/browser/ui/app_list/app_list_extension_ordering.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_item_model.h"
 
 namespace {
 
 const char kHostedAppId[] = "dceacbkfkmllgmjmbhgkpjegnodmildf";
@@ skipping 136 matching lines @@
 
   loop_.RunUntilIdle();
 }
 
 TEST_F(AppsModelBuilderTest, OrdinalPrefsChange) {
   scoped_ptr<app_list::AppListModel::Apps> model(
       new app_list::AppListModel::Apps);
   AppsModelBuilder builder(profile_.get(), model.get(), NULL);
   builder.Build();
 
-  ExtensionSorting* sorting = service_->extension_prefs()->extension_sorting();
+  AppListExtensionOrdering* ordering =
+      service_->extension_prefs()->app_list_extension_ordering();
 
-  syncer::StringOrdinal package_app_page =
-      sorting->GetPageOrdinal(kPackagedApp1Id);
-  sorting->SetPageOrdinal(kHostedAppId, package_app_page.CreateBefore());
+  syncer::StringOrdinal app1_ordinal =
+      ordering->GetAppListOrdinal(kPackagedApp1Id);
+  syncer::StringOrdinal app2_ordinal =
+      ordering->GetAppListOrdinal(kPackagedApp2Id);
+
+  ordering->Erase(kHostedAppId);
+  ordering->SetAppListOrdinalForSync(kHostedAppId, app1_ordinal.CreateBefore());
   EXPECT_EQ(std::string("Hosted App,Packaged App 1,Packaged App 2"),
             GetModelContent(model.get()));
 
-  syncer::StringOrdinal app1_ordinal =
-      sorting->GetAppLaunchOrdinal(kPackagedApp1Id);
-  syncer::StringOrdinal app2_ordinal =
-      sorting->GetAppLaunchOrdinal(kPackagedApp2Id);
-  sorting->SetPageOrdinal(kHostedAppId, package_app_page);
-  sorting->SetAppLaunchOrdinal(kHostedAppId,
-                               app1_ordinal.CreateBetween(app2_ordinal));
+  ordering->Erase(kHostedAppId);
+  ordering->SetAppListOrdinalForSync(kHostedAppId,
+                                     app1_ordinal.CreateBetween(app2_ordinal));
   EXPECT_EQ(std::string("Packaged App 1,Hosted App,Packaged App 2"),
             GetModelContent(model.get()));
 }
 
 TEST_F(AppsModelBuilderTest, OnExtensionMoved) {
   scoped_ptr<app_list::AppListModel::Apps> model(
       new app_list::AppListModel::Apps);
   AppsModelBuilder builder(profile_.get(), model.get(), NULL);
   builder.Build();
 
-  ExtensionSorting* sorting = service_->extension_prefs()->extension_sorting();
-  sorting->SetPageOrdinal(kHostedAppId,
-                          sorting->GetPageOrdinal(kPackagedApp1Id));
+  AppListExtensionOrdering* ordering =
+      service_->extension_prefs()->app_list_extension_ordering();
 
-  service_->OnExtensionMoved(kHostedAppId, kPackagedApp1Id, kPackagedApp2Id);
+  ordering->OnExtensionMoved(kHostedAppId, kPackagedApp1Id, kPackagedApp2Id);
   EXPECT_EQ(std::string("Packaged App 1,Hosted App,Packaged App 2"),
             GetModelContent(model.get()));
 
-  service_->OnExtensionMoved(kHostedAppId, kPackagedApp2Id, std::string());
+  ordering->OnExtensionMoved(kHostedAppId, kPackagedApp2Id, std::string());
   EXPECT_EQ(std::string("Packaged App 1,Packaged App 2,Hosted App"),
             GetModelContent(model.get()));
 
-  service_->OnExtensionMoved(kHostedAppId, std::string(), kPackagedApp1Id);
+  ordering->OnExtensionMoved(kHostedAppId, std::string(), kPackagedApp1Id);
   EXPECT_EQ(std::string("Hosted App,Packaged App 1,Packaged App 2"),
             GetModelContent(model.get()));
 }
 
 TEST_F(AppsModelBuilderTest, InvalidOrdinal) {
   // Creates a no-ordinal case.
-  ExtensionSorting* sorting = service_->extension_prefs()->extension_sorting();
-  sorting->ClearOrdinals(kPackagedApp1Id);
+  AppListExtensionOrdering* ordering =
+      service_->extension_prefs()->app_list_extension_ordering();
+  ordering->Erase(kPackagedApp1Id);
 
   // Creates an corrupted ordinal case.
   ExtensionScopedPrefs* scoped_prefs = service_->extension_prefs();
   scoped_prefs->UpdateExtensionPref(
       kHostedAppId,
-      "page_ordinal",
+      "app_list_ordinal",
       base::Value::CreateStringValue("a corrupted ordinal"));
 
   scoped_ptr<app_list::AppListModel::Apps> model(
       new app_list::AppListModel::Apps);
   AppsModelBuilder builder(profile_.get(), model.get(), NULL);
 
   // This should not assert or crash.
   builder.Build();
 }
 
 TEST_F(AppsModelBuilderTest, OrdinalConfilicts) {
   // Creates conflict ordinals for app1 and app2.
   syncer::StringOrdinal conflict_ordinal =
       syncer::StringOrdinal::CreateInitialOrdinal();
 
-  ExtensionSorting* sorting = service_->extension_prefs()->extension_sorting();
-  sorting->SetPageOrdinal(kHostedAppId, conflict_ordinal);
-  sorting->SetAppLaunchOrdinal(kHostedAppId, conflict_ordinal);
+  AppListExtensionOrdering* ordering =
+      service_->extension_prefs()->app_list_extension_ordering();
+  ordering->Erase(kHostedAppId);
+  ordering->Erase(kPackagedApp1Id);
+  ordering->Erase(kPackagedApp2Id);
 
-  sorting->SetPageOrdinal(kPackagedApp1Id, conflict_ordinal);
-  sorting->SetAppLaunchOrdinal(kPackagedApp1Id, conflict_ordinal);
-
-  sorting->SetPageOrdinal(kPackagedApp2Id, conflict_ordinal);
-  sorting->SetAppLaunchOrdinal(kPackagedApp2Id, conflict_ordinal);
+  ordering->SetAppListOrdinalForSync(kHostedAppId, conflict_ordinal);
+  ordering->SetAppListOrdinalForSync(kPackagedApp1Id, conflict_ordinal);
+  ordering->SetAppListOrdinalForSync(kPackagedApp2Id, conflict_ordinal);
 
   scoped_ptr<app_list::AppListModel::Apps> model(
       new app_list::AppListModel::Apps);
   AppsModelBuilder builder(profile_.get(), model.get(), NULL);
+  // This fixes the collisions.
   builder.Build();
 
   // By default, conflicted items are sorted by their app ids.
   EXPECT_EQ(std::string("Hosted App,Packaged App 1,Packaged App 2"),
             GetModelContent(model.get()));
 
   // Move hosted app between app1 and app2 and it should not crash.
-  service_->OnExtensionMoved(kHostedAppId, kPackagedApp1Id, kPackagedApp2Id);
+  ordering->OnExtensionMoved(kHostedAppId, kPackagedApp1Id, kPackagedApp2Id);
   EXPECT_EQ(std::string("Packaged App 1,Hosted App,Packaged App 2"),
             GetModelContent(model.get()));
 }