app_sorting() calls should go via ExtensionSystem intsead of prefs.

chrome/browser/ui/app_list/extension_app_model_builder_unittest.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/ui/app_list/extension_app_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/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/ui/app_list/app_list_test_util.h"
 #include "chrome/browser/ui/app_list/test/test_app_list_controller_delegate.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.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/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_item.h"
 
+using extensions::AppSorting;
+using extensions::ExtensionSystem;
+
 namespace {
 
 // Get a string of all apps in |model| joined with ','.
 std::string GetModelContent(app_list::AppListModel* model) {
   std::string content;
   for (size_t i = 0; i < model->top_level_item_list()->item_count(); ++i) {
     if (i > 0)
       content += ',';
     content += model->top_level_item_list()->item_at(i)->name();
   }
@@ skipping 163 matching lines @@
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForBrowserContext(profile_.get());
   extensions::InstallObserver::ExtensionInstallParams params(
       kPackagedApp1Id, "", gfx::ImageSkia(), true, true);
   tracker->OnBeginExtensionInstall(params);
 
   EXPECT_EQ(std::string(kDefaultApps), GetModelContent(model_.get()));
 }
 
 TEST_F(ExtensionAppModelBuilderTest, OrdinalPrefsChange) {
-  extensions::AppSorting* sorting =
-      extensions::ExtensionPrefs::Get(profile_.get())->app_sorting();
+  AppSorting* sorting = ExtensionSystem::Get(profile_.get())->app_sorting();
 
   syncer::StringOrdinal package_app_page =
       sorting->GetPageOrdinal(kPackagedApp1Id);
   sorting->SetPageOrdinal(kHostedAppId, package_app_page.CreateBefore());
   // Old behavior: This would be "Hosted App,Packaged App 1,Packaged App 2"
   // New behavior: Sorting order doesn't change.
   EXPECT_EQ(std::string(kDefaultApps), 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));
   // Old behavior: This would be "Packaged App 1,Hosted App,Packaged App 2"
   // New behavior: Sorting order doesn't change.
   EXPECT_EQ(std::string(kDefaultApps), GetModelContent(model_.get()));
 }
 
 TEST_F(ExtensionAppModelBuilderTest, OnExtensionMoved) {
-  extensions::AppSorting* sorting =
-      extensions::ExtensionPrefs::Get(profile_.get())->app_sorting();
+  AppSorting* sorting = ExtensionSystem::Get(profile_.get())->app_sorting();
   sorting->SetPageOrdinal(kHostedAppId,
                           sorting->GetPageOrdinal(kPackagedApp1Id));
 
   sorting->OnExtensionMoved(kHostedAppId, kPackagedApp1Id, kPackagedApp2Id);
   // Old behavior: This would be "Packaged App 1,Hosted App,Packaged App 2"
   // New behavior: Sorting order doesn't change.
   EXPECT_EQ(std::string(kDefaultApps), GetModelContent(model_.get()));
 
   sorting->OnExtensionMoved(kHostedAppId, kPackagedApp2Id, std::string());
   // Old behavior: This would be restored to the default order.
   // New behavior: Sorting order still doesn't change.
   EXPECT_EQ(std::string(kDefaultApps), GetModelContent(model_.get()));
 
   sorting->OnExtensionMoved(kHostedAppId, std::string(), kPackagedApp1Id);
   // Old behavior: This would be "Hosted App,Packaged App 1,Packaged App 2"
   // New behavior: Sorting order doesn't change.
   EXPECT_EQ(std::string(kDefaultApps), GetModelContent(model_.get()));
 }
 
 TEST_F(ExtensionAppModelBuilderTest, InvalidOrdinal) {
   // Creates a no-ordinal case.
-  extensions::AppSorting* sorting =
-      extensions::ExtensionPrefs::Get(profile_.get())->app_sorting();
+  AppSorting* sorting = ExtensionSystem::Get(profile_.get())->app_sorting();
   sorting->ClearOrdinals(kPackagedApp1Id);
 
   // Creates a corrupted ordinal case.
   extensions::ExtensionScopedPrefs* scoped_prefs =
       extensions::ExtensionPrefs::Get(profile_.get());
   scoped_prefs->UpdateExtensionPref(
       kHostedAppId,
       "page_ordinal",
       new base::StringValue("a corrupted ordinal"));
 
   // This should not assert or crash.
   CreateBuilder();
 }
 
 TEST_F(ExtensionAppModelBuilderTest, OrdinalConfilicts) {
   // Creates conflict ordinals for app1 and app2.
   syncer::StringOrdinal conflict_ordinal =
       syncer::StringOrdinal::CreateInitialOrdinal();
 
-  extensions::AppSorting* sorting =
-      extensions::ExtensionPrefs::Get(profile_.get())->app_sorting();
+  AppSorting* sorting = ExtensionSystem::Get(profile_.get())->app_sorting();
   sorting->SetPageOrdinal(kHostedAppId, conflict_ordinal);
   sorting->SetAppLaunchOrdinal(kHostedAppId, conflict_ordinal);
 
   sorting->SetPageOrdinal(kPackagedApp1Id, conflict_ordinal);
   sorting->SetAppLaunchOrdinal(kPackagedApp1Id, conflict_ordinal);
 
   sorting->SetPageOrdinal(kPackagedApp2Id, conflict_ordinal);
   sorting->SetAppLaunchOrdinal(kPackagedApp2Id, conflict_ordinal);
 
   // This should not assert or crash.
@@ skipping 23 matching lines @@
           extensions::Extension::WAS_INSTALLED_BY_DEFAULT |
               extensions::Extension::FROM_BOOKMARK,
           kAppId,
           &err);
   EXPECT_TRUE(err.empty());
 
   service_->AddExtension(bookmark_app.get());
   EXPECT_EQ(kDefaultAppCount + 1, model_->top_level_item_list()->item_count());
   EXPECT_NE(std::string::npos, GetModelContent(model_.get()).find(kAppName));
 }