Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

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 "extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/public/pref_change_registrar.h"
@@ skipping 450 matching lines @@
 };
 TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
 
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     extension = prefs_.AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
     prefs()->OnExtensionUninstalled(extension->id(),
-                                    Extension::INTERNAL, false);
+                                    Manifest::INTERNAL, false);
   }
 
   virtual void Verify() {
     EXPECT_EQ("", prefs()->GetVersionString(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsVersionString, VersionString) {}
@@ skipping 102 matching lines @@
  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));
     FilePath path = prefs_.extensions_dir().AppendASCII(base::IntToString(num));
     std::string errors;
     scoped_refptr<Extension> extension = Extension::Create(
-        path, Extension::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
+        path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
     ASSERT_TRUE(extension) << errors;
     ASSERT_EQ(id, extension->id());
     prefs()->SetDelayedInstallInfo(extension.get(), Extension::ENABLED,
                                    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));
@@ skipping 128 matching lines @@
 TEST_F(ExtensionPrefsAppDraggedByUser, ExtensionPrefsAppDraggedByUser) {}
 
 class ExtensionPrefsFlags : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName, "from_webstore");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
-          dictionary, Extension::INTERNAL, Extension::FROM_WEBSTORE);
+          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");
       bookmark_extension_ = prefs_.AddExtensionWithManifestAndFlags(
-          dictionary, Extension::INTERNAL, Extension::FROM_BOOKMARK);
+          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");
       default_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary,
-          Extension::INTERNAL,
+          Manifest::INTERNAL,
           Extension::WAS_INSTALLED_BY_DEFAULT);
     }
   }
 
   virtual void Verify() {
     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()));
@@ skipping 17 matching lines @@
       ext3_(NULL),
       ext4_(NULL),
       installed() {
   DictionaryValue simple_dict;
   std::string error;
 
   simple_dict.SetString(keys::kVersion, "1.0.0.0");
   simple_dict.SetString(keys::kName, "unused");
 
   ext1_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext1_"), Extension::EXTERNAL_PREF,
+      prefs_.temp_dir().AppendASCII("ext1_"), Manifest::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext2_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext2_"), Extension::EXTERNAL_PREF,
+      prefs_.temp_dir().AppendASCII("ext2_"), Manifest::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext3_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext3_"), Extension::EXTERNAL_PREF,
+      prefs_.temp_dir().AppendASCII("ext3_"), Manifest::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext4_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext4_"), Extension::EXTERNAL_PREF,
+      prefs_.temp_dir().AppendASCII("ext4_"), Manifest::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
 
   ext1_ = ext1_scoped_.get();
   ext2_ = ext2_scoped_.get();
   ext3_ = ext3_scoped_.get();
   ext4_ = ext4_scoped_.get();
 
   for (size_t i = 0; i < arraysize(installed); ++i)
     installed[i] = false;
 }
@@ skipping 62 matching lines @@
 
 void ExtensionPrefsPrepopulatedTest::EnsureExtensionUninstalled(
     const std::string& extension_id) {
   Extension* extensions[] = {ext1_, ext2_, ext3_, ext4_};
   for (size_t i = 0; i < arraysize(extensions); ++i) {
     if (extensions[i]->id() == extension_id) {
       installed[i] = false;
       break;
     }
   }
-  prefs()->OnExtensionUninstalled(extension_id, Extension::INTERNAL, false);
+  prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false);
 }
 
 class ExtensionPrefsInstallOneExtension
     : public ExtensionPrefsPrepopulatedTest {
   virtual void Initialize() {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
   }
   virtual void Verify() {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
@@ skipping 342 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