Rename extension_manifest_keys namespace to extensions::manifest_keys.

chrome/browser/extensions/extension_prefs_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 "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_pref_value_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_paths.h"
-#include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/mock_notification_observer.h"
+#include "extensions/common/manifest_constants.h"
 #include "sync/api/string_ordinal.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace extensions {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
@@ skipping 396 matching lines @@
   std::string blacklisted_id_;
 };
 TEST_F(ExtensionPrefsAcknowledgment, Acknowledgment) {}
 
 // Tests the idle install information functions.
 class ExtensionPrefsDelayedInstallInfo : public ExtensionPrefsTest {
  public:
   // Sets idle install information for one test extension.
   void SetIdleInfo(std::string id, int num) {
     DictionaryValue manifest;
-    manifest.SetString(extension_manifest_keys::kName, "test");
-    manifest.SetString(extension_manifest_keys::kVersion,
-                       "1." + base::IntToString(num));
+    manifest.SetString(manifest_keys::kName, "test");
+    manifest.SetString(manifest_keys::kVersion, "1." + base::IntToString(num));
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII(base::IntToString(num));
     std::string errors;
     scoped_refptr<Extension> extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
     ASSERT_TRUE(extension.get()) << errors;
     ASSERT_EQ(id, extension->id());
     prefs()->SetDelayedInstallInfo(extension.get(),
                                    Extension::ENABLED,
                                    Blacklist::NOT_BLACKLISTED,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal());
   }
 
   // Verifies that we get back expected idle install information previously
   // set by SetIdleInfo.
   void VerifyIdleInfo(std::string id, int num) {
     scoped_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
     ASSERT_TRUE(info);
     std::string version;
     ASSERT_TRUE(info->extension_manifest->GetString("version", &version));
     ASSERT_EQ("1." + base::IntToString(num), version);
     ASSERT_EQ(base::IntToString(num),
               info->extension_path.BaseName().MaybeAsASCII());
   }
 
-  bool HasInfoForId(extensions::ExtensionPrefs::ExtensionsInfo* info,
+  bool HasInfoForId(ExtensionPrefs::ExtensionsInfo* info,
                     const std::string& id) {
     for (size_t i = 0; i < info->size(); ++i) {
       if (info->at(i)->extension_id == id)
         return true;
     }
     return false;
   }
 
   virtual void Initialize() OVERRIDE {
     PathService::Get(chrome::DIR_TEST_DATA, &basedir_);
     now_ = Time::Now();
     id1_ = prefs_.AddExtensionAndReturnId("1");
     id2_ = prefs_.AddExtensionAndReturnId("2");
     id3_ = prefs_.AddExtensionAndReturnId("3");
     id4_ = prefs_.AddExtensionAndReturnId("4");
 
     // Set info for two extensions, then remove it.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
-    scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> info(
+    scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
         prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(2u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     prefs()->RemoveDelayedInstallInfo(id1_);
     prefs()->RemoveDelayedInstallInfo(id2_);
     info = prefs()->GetAllDelayedInstallInfo();
     EXPECT_TRUE(info->empty());
 
     // Try getting/removing info for an id that used to have info set.
@@ skipping 11 matching lines @@
     SetIdleInfo(id4_, 4);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id3_, 3);
     VerifyIdleInfo(id4_, 4);
     prefs()->RemoveDelayedInstallInfo(id3_);
   }
 
   virtual void Verify() OVERRIDE {
     // Make sure the info for the 3 extensions we expect is present.
-    scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> info(
+    scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
         prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(3u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     EXPECT_TRUE(HasInfoForId(info.get(), id4_));
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id4_, 4);
 
     // Make sure there isn't info the for the one extension id we removed.
     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
   }
 
  protected:
   Time now_;
   base::FilePath basedir_;
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
 TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 
 // Tests the FinishDelayedInstallInfo function.
 class ExtensionPrefsFinishDelayedInstallInfo : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     DictionaryValue dictionary;
-    dictionary.SetString(extension_manifest_keys::kName, "test");
-    dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
-    dictionary.SetString(extension_manifest_keys::kBackgroundPage,
-        "background.html");
+    dictionary.SetString(manifest_keys::kName, "test");
+    dictionary.SetString(manifest_keys::kVersion, "0.1");
+    dictionary.SetString(manifest_keys::kBackgroundPage, "background.html");
     scoped_refptr<Extension> extension =
         prefs_.AddExtensionWithManifest(dictionary, Manifest::INTERNAL);
     id_ = extension->id();
 
 
     // Set idle info
     DictionaryValue manifest;
-    manifest.SetString(extension_manifest_keys::kName, "test");
-    manifest.SetString(extension_manifest_keys::kVersion, "0.2");
+    manifest.SetString(manifest_keys::kName, "test");
+    manifest.SetString(manifest_keys::kVersion, "0.2");
     scoped_ptr<ListValue> scripts(new ListValue);
     scripts->AppendString("test.js");
-    manifest.Set(extension_manifest_keys::kBackgroundScripts,
-        scripts.release());
+    manifest.Set(manifest_keys::kBackgroundScripts, scripts.release());
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII("test_0.2");
     std::string errors;
     scoped_refptr<Extension> new_extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id_, &errors);
     ASSERT_TRUE(new_extension.get()) << errors;
     ASSERT_EQ(id_, new_extension->id());
     prefs()->SetDelayedInstallInfo(new_extension.get(),
                                    Extension::ENABLED,
                                    Blacklist::NOT_BLACKLISTED,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal());
 
     // Finish idle installation
     ASSERT_TRUE(prefs()->FinishDelayedInstallInfo(id_));
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id_));
 
     const DictionaryValue* manifest;
     ASSERT_TRUE(prefs()->ReadPrefAsDictionary(id_, "manifest", &manifest));
     ASSERT_TRUE(manifest);
     std::string value;
-    EXPECT_TRUE(manifest->GetString(extension_manifest_keys::kName, &value));
+    EXPECT_TRUE(manifest->GetString(manifest_keys::kName, &value));
     EXPECT_EQ("test", value);
-    EXPECT_TRUE(manifest->GetString(extension_manifest_keys::kVersion, &value));
+    EXPECT_TRUE(manifest->GetString(manifest_keys::kVersion, &value));
     EXPECT_EQ("0.2", value);
-    EXPECT_FALSE(manifest->GetString(extension_manifest_keys::kBackgroundPage,
-                                     &value));
+    EXPECT_FALSE(manifest->GetString(manifest_keys::kBackgroundPage, &value));
     const ListValue* scripts;
-    ASSERT_TRUE(manifest->GetList(extension_manifest_keys::kBackgroundScripts,
-                                  &scripts));
+    ASSERT_TRUE(manifest->GetList(manifest_keys::kBackgroundScripts, &scripts));
     EXPECT_EQ(1u, scripts->GetSize());
   }
 
  protected:
   std::string id_;
 };
 TEST_F(ExtensionPrefsFinishDelayedInstallInfo, FinishDelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
@@ skipping 40 matching lines @@
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsAppDraggedByUser, ExtensionPrefsAppDraggedByUser) {}
 
 class ExtensionPrefsFlags : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     {
       base::DictionaryValue dictionary;
-      dictionary.SetString(extension_manifest_keys::kName, "from_webstore");
-      dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
+      dictionary.SetString(manifest_keys::kName, "from_webstore");
+      dictionary.SetString(manifest_keys::kVersion, "0.1");
       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_WEBSTORE);
     }
 
     {
       base::DictionaryValue dictionary;
-      dictionary.SetString(extension_manifest_keys::kName, "from_bookmark");
-      dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
+      dictionary.SetString(manifest_keys::kName, "from_bookmark");
+      dictionary.SetString(manifest_keys::kVersion, "0.1");
       bookmark_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_BOOKMARK);
     }
 
     {
       base::DictionaryValue dictionary;
-      dictionary.SetString(extension_manifest_keys::kName,
-                           "was_installed_by_default");
-      dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
+      dictionary.SetString(manifest_keys::kName, "was_installed_by_default");
+      dictionary.SetString(manifest_keys::kVersion, "0.1");
       default_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary,
           Manifest::INTERNAL,
           Extension::WAS_INSTALLED_BY_DEFAULT);
     }
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_TRUE(prefs()->IsFromWebStore(webstore_extension_->id()));
     EXPECT_FALSE(prefs()->IsFromBookmark(webstore_extension_->id()));
 
     EXPECT_TRUE(prefs()->IsFromBookmark(bookmark_extension_->id()));
     EXPECT_FALSE(prefs()->IsFromWebStore(bookmark_extension_->id()));
 
     EXPECT_TRUE(prefs()->WasInstalledByDefault(default_extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> webstore_extension_;
   scoped_refptr<Extension> bookmark_extension_;
   scoped_refptr<Extension> default_extension_;
 };
 TEST_F(ExtensionPrefsFlags, ExtensionPrefsFlags) {}
 
 PrefsPrepopulatedTestBase::PrefsPrepopulatedTestBase()
     : ExtensionPrefsTest() {
   DictionaryValue simple_dict;
   std::string error;
 
-  simple_dict.SetString(extension_manifest_keys::kVersion, "1.0.0.0");
-  simple_dict.SetString(extension_manifest_keys::kName, "unused");
+  simple_dict.SetString(manifest_keys::kVersion, "1.0.0.0");
+  simple_dict.SetString(manifest_keys::kName, "unused");
 
   extension1_ = Extension::Create(
       prefs_.temp_dir().AppendASCII("ext1_"),
       Manifest::EXTERNAL_PREF,
       simple_dict,
       Extension::NO_FLAGS,
       &error);
   extension2_ = Extension::Create(
       prefs_.temp_dir().AppendASCII("ext2_"),
       Manifest::EXTERNAL_PREF,
@@ skipping 93 matching lines @@
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions