Moved ExtensionPrefs and related into extensions namespace

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_prefs_unittest.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
 
 namespace keys = extension_manifest_keys;
 
-class ExtensionSortingTest : public ExtensionPrefsTest {
+class ExtensionSortingTest : public extensions::ExtensionPrefsTest {
  protected:
   ExtensionSorting* extension_sorting() {
     return prefs()->extension_sorting();
   }
 };
 
 class ExtensionSortingAppLocation : public ExtensionSortingTest {
  public:
   virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddExtension("not_an_app");
@@ skipping 102 matching lines @@
 
  private:
   StringOrdinal first_page_;
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionSortingPageOrdinal, ExtensionSortingPageOrdinal) {}
 
 // Ensure that ExtensionSorting is able to properly initialize off a set
 // of old page and app launch indices and properly convert them.
 class ExtensionSortingInitialize
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingInitialize() {}
   virtual ~ExtensionSortingInitialize() {}
 
   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 16 matching lines @@
 
     scoped_prefs->UpdateExtensionPref(ext3_->id(),
                                       kPrefAppLaunchIndexDeprecated,
                                       Value::CreateIntegerValue(0));
     scoped_prefs->UpdateExtensionPref(ext3_->id(),
                                       kPrefPageIndexDeprecated,
                                       Value::CreateIntegerValue(1));
 
     // We insert the ids in reserve order so that we have to deal with the
     // element on the 2nd page before the 1st page is seen.
-    ExtensionPrefs::ExtensionIdSet ids;
+    extensions::ExtensionPrefs::ExtensionIdSet ids;
     ids.push_back(ext3_->id());
     ids.push_back(ext2_->id());
     ids.push_back(ext1_->id());
 
     prefs()->extension_sorting()->Initialize(ids);
   }
   virtual void Verify() OVERRIDE {
     StringOrdinal first_ordinal = StringOrdinal::CreateInitialOrdinal();
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
@@ skipping 10 matching lines @@
         extension_sorting->GetPageOrdinal(ext2_->id())));
     EXPECT_TRUE(first_ordinal.LessThan(
         extension_sorting->GetPageOrdinal(ext3_->id())));
   }
 };
 TEST_F(ExtensionSortingInitialize, ExtensionSortingInitialize) {}
 
 // Make sure that initialization still works when no extensions are present
 // (i.e. make sure that the web store icon is still loaded into the map).
 class ExtensionSortingInitializeWithNoApps
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingInitializeWithNoApps() {}
   virtual ~ExtensionSortingInitializeWithNoApps() {}
 
   virtual void Initialize() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     // Make sure that the web store has valid ordinals.
     StringOrdinal initial_ordinal = StringOrdinal::CreateInitialOrdinal();
     extension_sorting->SetPageOrdinal(extension_misc::kWebStoreAppId,
                                       initial_ordinal);
     extension_sorting->SetAppLaunchOrdinal(extension_misc::kWebStoreAppId,
                                            initial_ordinal);
 
-    ExtensionPrefs::ExtensionIdSet ids;
+    extensions::ExtensionPrefs::ExtensionIdSet ids;
     extension_sorting->Initialize(ids);
   }
   virtual void Verify() OVERRIDE {
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     StringOrdinal page =
         extension_sorting->GetPageOrdinal(extension_misc::kWebStoreAppId);
     EXPECT_TRUE(page.IsValid());
 
     ExtensionSorting::PageOrdinalMap::iterator page_it =
@@ skipping 10 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 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";
 
     // Setup the deprecated preference.
     ExtensionScopedPrefs* scoped_prefs =
         static_cast<ExtensionScopedPrefs*>(prefs());
     scoped_prefs->UpdateExtensionPref(ext1_->id(),
                                       kPrefAppLaunchIndexDeprecated,
                                       Value::CreateIntegerValue(0));
     scoped_prefs->UpdateExtensionPref(ext1_->id(),
                                       kPrefPageIndexDeprecated,
                                       Value::CreateIntegerValue(-1));
 
-    ExtensionPrefs::ExtensionIdSet ids;
+    extensions::ExtensionPrefs::ExtensionIdSet ids;
     ids.push_back(ext1_->id());
 
     prefs()->extension_sorting()->Initialize(ids);
   }
   virtual void Verify() OVERRIDE {
     // Make sure that the invalid page_index wasn't converted over.
     EXPECT_FALSE(prefs()->extension_sorting()->GetAppLaunchOrdinal(
         ext1_->id()).IsValid());
   }
 };
 TEST_F(ExtensionSortingMigrateAppIndexInvalid,
        ExtensionSortingMigrateAppIndexInvalid) {}
 
 class ExtensionSortingFixNTPCollisionsAllCollide
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingFixNTPCollisionsAllCollide() {}
   virtual ~ExtensionSortingFixNTPCollisionsAllCollide() {}
 
   virtual void Initialize() OVERRIDE {
     repeated_ordinal_ = StringOrdinal::CreateInitialOrdinal();
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
     extension_sorting->SetAppLaunchOrdinal(ext1_->id(), repeated_ordinal_);
@@ skipping 34 matching lines @@
         repeated_ordinal_));
   }
 
  private:
   StringOrdinal repeated_ordinal_;
 };
 TEST_F(ExtensionSortingFixNTPCollisionsAllCollide,
        ExtensionSortingFixNTPCollisionsAllCollide) {}
 
 class ExtensionSortingFixNTPCollisionsSomeCollideAtStart
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingFixNTPCollisionsSomeCollideAtStart() {}
   virtual ~ExtensionSortingFixNTPCollisionsSomeCollideAtStart() {}
 
   virtual void Initialize() OVERRIDE {
     first_ordinal_ = StringOrdinal::CreateInitialOrdinal();
     StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
@@ skipping 37 matching lines @@
         first_ordinal_));
   }
 
  private:
   StringOrdinal first_ordinal_;
 };
 TEST_F(ExtensionSortingFixNTPCollisionsSomeCollideAtStart,
        ExtensionSortingFixNTPCollisionsSomeCollideAtStart) {}
 
 class ExtensionSortingFixNTPCollisionsSomeCollideAtEnd
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingFixNTPCollisionsSomeCollideAtEnd() {}
   virtual ~ExtensionSortingFixNTPCollisionsSomeCollideAtEnd() {}
 
   virtual void Initialize() OVERRIDE {
     first_ordinal_ = StringOrdinal::CreateInitialOrdinal();
     StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
@@ skipping 37 matching lines @@
         first_ordinal_));
   }
 
  private:
   StringOrdinal first_ordinal_;
 };
 TEST_F(ExtensionSortingFixNTPCollisionsSomeCollideAtEnd,
        ExtensionSortingFixNTPCollisionsSomeCollideAtEnd) {}
 
 class ExtensionSortingFixNTPCollisionsTwoCollisions
-    : public ExtensionPrefsPrepopulatedTest {
+    : public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingFixNTPCollisionsTwoCollisions() {}
   virtual ~ExtensionSortingFixNTPCollisionsTwoCollisions() {}
 
   virtual void Initialize() OVERRIDE {
     first_ordinal_ = StringOrdinal::CreateInitialOrdinal();
     StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
 
@@ skipping 47 matching lines @@
         first_ordinal_));
   }
 
  private:
   StringOrdinal first_ordinal_;
 };
 TEST_F(ExtensionSortingFixNTPCollisionsTwoCollisions,
        ExtensionSortingFixNTPCollisionsTwoCollisions) {}
 
 class ExtensionSortingEnsureValidOrdinals :
-    public ExtensionPrefsPrepopulatedTest {
+    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 EnsureValidOridnals fixes
     // them.
     extension_sorting->SetAppLaunchOrdinal(ext1_->id(), StringOrdinal());
     extension_sorting->SetPageOrdinal(ext1_->id(), StringOrdinal());
 
     extension_sorting->EnsureValidOrdinals(ext1_->id());
 
     EXPECT_TRUE(extension_sorting->GetAppLaunchOrdinal(ext1_->id()).IsValid());
     EXPECT_TRUE(extension_sorting->GetPageOrdinal(ext1_->id()).IsValid());
   }
 };
 TEST_F(ExtensionSortingEnsureValidOrdinals,
        ExtensionSortingEnsureValidOrdinals) {}
 
 class ExtensionSortingPageOrdinalMapping :
-    public ExtensionPrefsPrepopulatedTest {
+    public extensions::ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionSortingPageOrdinalMapping() {}
   virtual ~ExtensionSortingPageOrdinalMapping() {}
 
   virtual void Initialize() {}
   virtual void Verify() {
     std::string ext_1 = "ext_1";
     std::string ext_2 = "ext_2";
 
     ExtensionSorting* extension_sorting = prefs()->extension_sorting();
@@ skipping 38 matching lines @@
 
     it = extension_sorting->ntp_ordinal_map_[first_ordinal].find(
         first_ordinal);
     EXPECT_EQ(ext_2, it->second);
   }
 };
 TEST_F(ExtensionSortingPageOrdinalMapping,
        ExtensionSortingPageOrdinalMapping) {}
 
 class ExtensionSortingPreinstalledAppsBase :
-    public ExtensionPrefsPrepopulatedTest {
+    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 132 matching lines @@
     extension_sorting->SetPageOrdinal(app1_->id(), page_three);
     EXPECT_EQ(2, extension_sorting->PageStringOrdinalAsInteger(page_three));
 
     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) {}