cros: Implement default app ordering.

chrome/browser/extensions/extension_sorting_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/extensions/extension_sorting.h"
+
+#include <map>
+
 #include "chrome/browser/extensions/extension_prefs_unittest.h"
-#include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "sync/api/string_ordinal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
 
 namespace keys = extension_manifest_keys;
 
 class ExtensionSortingTest : public extensions::ExtensionPrefsTest {
  protected:
@@ skipping 72 matching lines @@
         extension_sorting()->CreateFirstAppLaunchOrdinal(next_page)));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionSortingAppLaunchOrdinal, ExtensionSortingAppLaunchOrdinal) {}
 
 class ExtensionSortingPageOrdinal : public ExtensionSortingTest {
  public:
-  virtual void Initialize() OVERRIDE{
+  virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddApp("page_ordinal");
     // Install with a page preference.
     first_page_ = syncer::StringOrdinal::CreateInitialOrdinal();
     prefs()->OnExtensionInstalled(extension_.get(), Extension::ENABLED,
                                   false, first_page_);
     EXPECT_TRUE(first_page_.Equals(
         extension_sorting()->GetPageOrdinal(extension_->id())));
     EXPECT_EQ(0, extension_sorting()->PageStringOrdinalAsInteger(first_page_));
 
     scoped_refptr<Extension> extension2 = prefs_.AddApp("page_ordinal_2");
@@ skipping 135 matching lines @@
   }
 };
 TEST_F(ExtensionSortingInitializeWithNoApps,
        ExtensionSortingInitializeWithNoApps) {}
 
 // Tests the application index to ordinal migration code for values that
 // shouldn't be converted. This should be removed when the migrate code
 // is taken out.
 // http://crbug.com/107376
 class ExtensionSortingMigrateAppIndexInvalid
- : public extensions::ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingMigrateAppIndexInvalid() {}
   virtual ~ExtensionSortingMigrateAppIndexInvalid() {}
 
   virtual void Initialize() OVERRIDE {
     // A preference determining the order of which the apps appear on the NTP.
     const char kPrefAppLaunchIndexDeprecated[] = "app_launcher_index";
     // A preference determining the page on which an app appears in the NTP.
     const char kPrefPageIndexDeprecated[] = "page_index";
 
@@ skipping 253 matching lines @@
     EXPECT_TRUE(extension_sorting->GetPageOrdinal(ext4_->id()).Equals(
         first_ordinal_));
   }
 
  private:
   syncer::StringOrdinal first_ordinal_;
 };
 TEST_F(ExtensionSortingFixNTPCollisionsTwoCollisions,
        ExtensionSortingFixNTPCollisionsTwoCollisions) {}
 
-class ExtensionSortingEnsureValidOrdinals :
-    public extensions::ExtensionPrefsPrepopulatedTest {
+class ExtensionSortingEnsureValidOrdinals
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public :
   ExtensionSortingEnsureValidOrdinals() {}
   ~ExtensionSortingEnsureValidOrdinals() {}
 
   virtual void Initialize() {}
   virtual void Verify() {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     // Give ext1 invalid ordinals and then check that EnsureValidOrdinals fixes
     // them.
     extension_sorting->SetAppLaunchOrdinal(ext1_->id(),
                                            syncer::StringOrdinal());
     extension_sorting->SetPageOrdinal(ext1_->id(), syncer::StringOrdinal());
 
-    extension_sorting->EnsureValidOrdinals(ext1_->id());
+    extension_sorting->EnsureValidOrdinals(ext1_->id(),
+                                           syncer::StringOrdinal());
 
     EXPECT_TRUE(extension_sorting->GetAppLaunchOrdinal(ext1_->id()).IsValid());
     EXPECT_TRUE(extension_sorting->GetPageOrdinal(ext1_->id()).IsValid());
   }
 };
 TEST_F(ExtensionSortingEnsureValidOrdinals,
        ExtensionSortingEnsureValidOrdinals) {}
 
-class ExtensionSortingPageOrdinalMapping :
-    public extensions::ExtensionPrefsPrepopulatedTest {
+class ExtensionSortingPageOrdinalMapping
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingPageOrdinalMapping() {}
   virtual ~ExtensionSortingPageOrdinalMapping() {}
 
-  virtual void Initialize() {}
-  virtual void Verify() {
+  virtual void Initialize() OVERRIDE {}
+  virtual void Verify() OVERRIDE {
     std::string ext_1 = "ext_1";
     std::string ext_2 = "ext_2";
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
     syncer::StringOrdinal first_ordinal =
         syncer::StringOrdinal::CreateInitialOrdinal();
 
     // Ensure attempting to removing a mapping with an invalid page doesn't
     // modify the map.
     EXPECT_TRUE(extension_sorting->ntp_ordinal_map_.empty());
@@ skipping 32 matching lines @@
     EXPECT_EQ(1U, extension_sorting->ntp_ordinal_map_[first_ordinal].size());
 
     it = extension_sorting->ntp_ordinal_map_[first_ordinal].find(
         first_ordinal);
     EXPECT_EQ(ext_2, it->second);
   }
 };
 TEST_F(ExtensionSortingPageOrdinalMapping,
        ExtensionSortingPageOrdinalMapping) {}
 
-class ExtensionSortingPreinstalledAppsBase :
-    public extensions::ExtensionPrefsPrepopulatedTest {
+class ExtensionSortingPreinstalledAppsBase
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingPreinstalledAppsBase() {
     DictionaryValue simple_dict;
     simple_dict.SetString(keys::kVersion, "1.0.0.0");
     simple_dict.SetString(keys::kName, "unused");
     simple_dict.SetString(keys::kApp, "true");
     simple_dict.SetString(keys::kLaunchLocalPath, "fake.html");
 
     std::string error;
     app1_scoped_ = Extension::Create(
@@ skipping 16 matching lines @@
     app2_ = app2_scoped_.get();
   }
   virtual ~ExtensionSortingPreinstalledAppsBase() {}
 
  protected:
   // Weak references, for convenience.
   Extension* app1_;
   Extension* app2_;
 
  private:
-    scoped_refptr<Extension> app1_scoped_;
-    scoped_refptr<Extension> app2_scoped_;
+  scoped_refptr<Extension> app1_scoped_;
+  scoped_refptr<Extension> app2_scoped_;
 };
 
-class ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage :
-    public ExtensionSortingPreinstalledAppsBase {
+class ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage
+    : public ExtensionSortingPreinstalledAppsBase {
  public:
   ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage() {}
   virtual ~ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage() {}
 
   virtual void Initialize() OVERRIDE {}
   virtual void Verify() OVERRIDE {
     syncer::StringOrdinal page = syncer::StringOrdinal::CreateInitialOrdinal();
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     syncer::StringOrdinal min =
@@ skipping 22 matching lines @@
         ExtensionSorting::MAX_ORDINAL);
     EXPECT_FALSE(min.IsValid());
     EXPECT_FALSE(max.IsValid());
   }
 };
 TEST_F(ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage,
        ExtensionSortingGetMinOrMaxAppLaunchOrdinalsOnPage) {}
 
 // Make sure that empty pages aren't removed from the integer to ordinal
 // mapping. See http://www.crbug.com/109802 for details.
-class ExtensionSortingKeepEmptyStringOrdinalPages :
-    public ExtensionSortingPreinstalledAppsBase {
+class ExtensionSortingKeepEmptyStringOrdinalPages
+    : public ExtensionSortingPreinstalledAppsBase {
  public:
   ExtensionSortingKeepEmptyStringOrdinalPages() {}
   virtual ~ExtensionSortingKeepEmptyStringOrdinalPages() {}
 
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     syncer::StringOrdinal first_page =
         syncer::StringOrdinal::CreateInitialOrdinal();
     extension_sorting->SetPageOrdinal(app1_->id(), first_page);
     EXPECT_EQ(0, extension_sorting->PageStringOrdinalAsInteger(first_page));
 
     last_page_ = first_page.CreateAfter();
     extension_sorting->SetPageOrdinal(app2_->id(), last_page_);
     EXPECT_EQ(1, extension_sorting->PageStringOrdinalAsInteger(last_page_));
 
     // Move the second app to create an empty page.
     extension_sorting->SetPageOrdinal(app2_->id(), first_page);
     EXPECT_EQ(0, extension_sorting->PageStringOrdinalAsInteger(first_page));
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     // Move the second app to a new empty page at the end, skipping over
     // the current empty page.
     last_page_ = last_page_.CreateAfter();
     extension_sorting->SetPageOrdinal(app2_->id(), last_page_);
     EXPECT_EQ(2, extension_sorting->PageStringOrdinalAsInteger(last_page_));
     EXPECT_TRUE(
         last_page_.Equals(extension_sorting->PageIntegerAsStringOrdinal(2)));
   }
 
  private:
   syncer::StringOrdinal last_page_;
 };
 TEST_F(ExtensionSortingKeepEmptyStringOrdinalPages,
        ExtensionSortingKeepEmptyStringOrdinalPages) {}
 
-class ExtensionSortingMakesFillerOrdinals :
-    public ExtensionSortingPreinstalledAppsBase {
+class ExtensionSortingMakesFillerOrdinals
+    : public ExtensionSortingPreinstalledAppsBase {
  public:
   ExtensionSortingMakesFillerOrdinals() {}
   virtual ~ExtensionSortingMakesFillerOrdinals() {}
 
-  virtual void Initialize() {
+  virtual void Initialize() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     syncer::StringOrdinal first_page =
         syncer::StringOrdinal::CreateInitialOrdinal();
     extension_sorting->SetPageOrdinal(app1_->id(), first_page);
     EXPECT_EQ(0, extension_sorting->PageStringOrdinalAsInteger(first_page));
   }
-  virtual void Verify() {
+  virtual void Verify() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     // Because the UI can add an unlimited number of empty pages without an app
     // on them, this test simulates dropping of an app on the 1st and 4th empty
     // pages (3rd and 6th pages by index) to ensure we don't crash and that
     // filler ordinals are created as needed. See: http://crbug.com/122214
     syncer::StringOrdinal page_three =
         extension_sorting->PageIntegerAsStringOrdinal(2);
     extension_sorting->SetPageOrdinal(app1_->id(), page_three);
     EXPECT_EQ(2, extension_sorting->PageStringOrdinalAsInteger(page_three));
 
     syncer::StringOrdinal page_six =
         extension_sorting->PageIntegerAsStringOrdinal(5);
     extension_sorting->SetPageOrdinal(app1_->id(), page_six);
     EXPECT_EQ(5, extension_sorting->PageStringOrdinalAsInteger(page_six));
   }
 };
 TEST_F(ExtensionSortingMakesFillerOrdinals,
        ExtensionSortingMakesFillerOrdinals) {}
+
+class ExtensionSortingDefaultOrdinalsBase : public ExtensionSortingTest {
+ public:
+  ExtensionSortingDefaultOrdinalsBase() {}
+  virtual ~ExtensionSortingDefaultOrdinalsBase() {}
+
+  virtual void Initialize() OVERRIDE {
+    app_ = CreateApp("app");
+
+    InitDefaultOrdinals();
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+    ExtensionSorting::AppOrdinalsMap& sorting_defaults =
+        extension_sorting->default_ordinals_;
+    sorting_defaults[app_->id()].page_ordinal = default_page_ordinal_;
+    sorting_defaults[app_->id()].app_launch_ordinal =
+        default_app_launch_ordinal_;
+
+    SetupUserOrdinals();
+    InstallApps();
+  }
+
+ protected:
+  scoped_refptr<Extension> CreateApp(const std::string& name) {
+    DictionaryValue simple_dict;
+    simple_dict.SetString(keys::kVersion, "1.0.0.0");
+    simple_dict.SetString(keys::kName, name);
+    simple_dict.SetString(keys::kApp, "true");
+    simple_dict.SetString(keys::kLaunchLocalPath, "fake.html");
+
+    std::string errors;
+    scoped_refptr<Extension> app = Extension::Create(
+        prefs_.temp_dir().AppendASCII(name), Extension::EXTERNAL_PREF,
+        simple_dict, Extension::NO_FLAGS, &errors);
+    EXPECT_TRUE(app) << errors;
+    EXPECT_TRUE(Extension::IdIsValid(app->id()));
+    return app;
+  }
+
+  void InitDefaultOrdinals() {
+    default_page_ordinal_ =
+        syncer::StringOrdinal::CreateInitialOrdinal().CreateAfter();
+    default_app_launch_ordinal_ =
+        syncer::StringOrdinal::CreateInitialOrdinal().CreateBefore();
+  }
+
+  virtual void SetupUserOrdinals() {}
+
+  virtual void InstallApps() {
+    prefs()->OnExtensionInstalled(app_.get(), Extension::ENABLED,
+                                  false, syncer::StringOrdinal());
+  }
+
+  scoped_refptr<Extension> app_;
+  syncer::StringOrdinal default_page_ordinal_;
+  syncer::StringOrdinal default_app_launch_ordinal_;
+};
+
+// Tests that the app gets its default ordinals.
+class ExtensionSortingDefaultOrdinals
+    : public ExtensionSortingDefaultOrdinalsBase {
+ public:
+  ExtensionSortingDefaultOrdinals() {}
+  virtual ~ExtensionSortingDefaultOrdinals() {}
+
+  virtual void Verify() OVERRIDE {
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+    EXPECT_TRUE(extension_sorting->GetPageOrdinal(app_->id()).Equals(
+        default_page_ordinal_));
+    EXPECT_TRUE(extension_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
+        default_app_launch_ordinal_));
+  }
+};
+TEST_F(ExtensionSortingDefaultOrdinals,
+       ExtensionSortingDefaultOrdinals) {}
+
+// Tests that the default page ordinal is overridden by install page ordinal.
+class ExtensionSortingDefaultOrdinalOverriddenByInstallPage
+    : public ExtensionSortingDefaultOrdinalsBase {
+ public:
+  ExtensionSortingDefaultOrdinalOverriddenByInstallPage() {}
+  virtual ~ExtensionSortingDefaultOrdinalOverriddenByInstallPage() {}
+
+  virtual void Verify() OVERRIDE {
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+
+    EXPECT_FALSE(extension_sorting->GetPageOrdinal(app_->id()).Equals(
+        default_page_ordinal_));
+    EXPECT_TRUE(extension_sorting->GetPageOrdinal(app_->id()).Equals(
+        install_page_));
+  }
+
+ protected:
+  virtual void InstallApps() OVERRIDE {
+    install_page_ = default_page_ordinal_.CreateAfter();
+    prefs()->OnExtensionInstalled(app_.get(), Extension::ENABLED,
+                                  false, install_page_);
+  }
+
+ private:
+  syncer::StringOrdinal install_page_;
+};
+TEST_F(ExtensionSortingDefaultOrdinalOverriddenByInstallPage,
+       ExtensionSortingDefaultOrdinalOverriddenByInstallPage) {}
+
+// Tests that the default ordinals are overridden by user values.
+class ExtensionSortingDefaultOrdinalOverriddenByUserValue
+    : public ExtensionSortingDefaultOrdinalsBase {
+ public:
+  ExtensionSortingDefaultOrdinalOverriddenByUserValue() {}
+  virtual ~ExtensionSortingDefaultOrdinalOverriddenByUserValue() {}
+
+  virtual void Verify() OVERRIDE {
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+
+    EXPECT_TRUE(extension_sorting->GetPageOrdinal(app_->id()).Equals(
+        user_page_ordinal_));
+    EXPECT_TRUE(extension_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
+        user_app_launch_ordinal_));
+  }
+
+ protected:
+  virtual void SetupUserOrdinals() {
+    user_page_ordinal_ = default_page_ordinal_.CreateAfter();
+    user_app_launch_ordinal_ = default_app_launch_ordinal_.CreateBefore();
+
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+    extension_sorting->SetPageOrdinal(app_->id(), user_page_ordinal_);
+    extension_sorting->SetAppLaunchOrdinal(app_->id(),
+                                           user_app_launch_ordinal_);
+  }
+
+ private:
+  syncer::StringOrdinal user_page_ordinal_;
+  syncer::StringOrdinal user_app_launch_ordinal_;
+};
+TEST_F(ExtensionSortingDefaultOrdinalOverriddenByUserValue,
+       ExtensionSortingDefaultOrdinalOverriddenByUserValue) {}
+
+// Tests that the default app launch ordinal is changed to avoid collision.
+class ExtensionSortingDefaultOrdinalNoCollision
+    : public ExtensionSortingDefaultOrdinalsBase {
+ public:
+  ExtensionSortingDefaultOrdinalNoCollision() {}
+  virtual ~ExtensionSortingDefaultOrdinalNoCollision() {}
+
+  virtual void Verify() OVERRIDE {
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+
+    // Use the default page.
+    EXPECT_TRUE(extension_sorting->GetPageOrdinal(app_->id()).Equals(
+        default_page_ordinal_));
+    // Not using the default app launch ordinal because of the collision.
+    EXPECT_FALSE(extension_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
+        default_app_launch_ordinal_));
+  }
+
+ protected:
+  virtual void SetupUserOrdinals() {
+    other_app_ = prefs_.AddApp("other_app");
+    // Creates a collision.
+    ExtensionSorting* extension_sorting = prefs()->extension_sorting();
+    extension_sorting->SetPageOrdinal(other_app_->id(), default_page_ordinal_);
+    extension_sorting->SetAppLaunchOrdinal(other_app_->id(),
+                                           default_app_launch_ordinal_);
+  }
+
+ private:
+  scoped_refptr<Extension> other_app_;
+};
+TEST_F(ExtensionSortingDefaultOrdinalNoCollision,
+       ExtensionSortingDefaultOrdinalNoCollision) {}