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

chrome/common/extensions/extension_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/common/extensions/extension.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/api/commands/commands_handler.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/features/feature.h"
+#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/common/extensions/permissions/usb_device_permission.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mock_host_resolver.h"
 #include "skia/ext/image_operations.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 using content::SocketPermissionRequest;
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
 namespace extensions {
 namespace {
 
 scoped_refptr<Extension> LoadManifestUnchecked(
     const std::string& dir,
     const std::string& test_file,
-    Extension::Location location,
+    Manifest::Location location,
     int extra_flags,
     std::string* error) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.AppendASCII("extensions")
              .AppendASCII(dir)
              .AppendASCII(test_file);
 
   JSONFileValueSerializer serializer(path);
   scoped_ptr<Value> result(serializer.Deserialize(NULL, error));
   if (!result.get())
     return NULL;
 
   scoped_refptr<Extension> extension = Extension::Create(
       path.DirName(), location, *static_cast<DictionaryValue*>(result.get()),
       extra_flags, error);
   return extension;
 }
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
                                              const std::string& test_file,
-                                             Extension::Location location,
+                                             Manifest::Location location,
                                              int extra_flags) {
   std::string error;
   scoped_refptr<Extension> extension = LoadManifestUnchecked(dir, test_file,
     location, extra_flags, &error);
 
   EXPECT_TRUE(extension) << test_file << ":" << error;
   return extension;
 }
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
                                              const std::string& test_file,
                                              int extra_flags) {
-  return LoadManifest(dir, test_file, Extension::INVALID, extra_flags);
+  return LoadManifest(dir, test_file, Manifest::INVALID_LOCATION, extra_flags);
 }
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
                                              const std::string& test_file) {
   return LoadManifest(dir, test_file, Extension::NO_FLAGS);
 }
 
 static scoped_refptr<Extension> LoadManifestStrict(
     const std::string& dir,
     const std::string& test_file) {
@@ skipping 11 matching lines @@
   }
   ADD_FAILURE() << "Expected manifest in " << manifest
                 << " to include a page_action section.";
   return scoped_ptr<ActionInfo>();
 }
 
 static void LoadActionAndExpectError(const std::string& manifest,
                                      const std::string& expected_error) {
   std::string error;
   scoped_refptr<Extension> extension = LoadManifestUnchecked("page_action",
-      manifest, Extension::INTERNAL, Extension::NO_FLAGS, &error);
+      manifest, Manifest::INTERNAL, Extension::NO_FLAGS, &error);
   EXPECT_FALSE(extension);
   EXPECT_EQ(expected_error, error);
 }
 
 }
 
 class ExtensionTest : public testing::Test {
  protected:
   virtual void SetUp() OVERRIDE {
     ManifestHandler::Register(extension_manifest_keys::kCommands,
                               new CommandsHandler);
   }
 };
 
 // We persist location values in the preferences, so this is a sanity test that
 // someone doesn't accidentally change them.
 TEST_F(ExtensionTest, LocationValuesTest) {
-  ASSERT_EQ(0, Extension::INVALID);
-  ASSERT_EQ(1, Extension::INTERNAL);
-  ASSERT_EQ(2, Extension::EXTERNAL_PREF);
-  ASSERT_EQ(3, Extension::EXTERNAL_REGISTRY);
-  ASSERT_EQ(4, Extension::LOAD);
-  ASSERT_EQ(5, Extension::COMPONENT);
-  ASSERT_EQ(6, Extension::EXTERNAL_PREF_DOWNLOAD);
-  ASSERT_EQ(7, Extension::EXTERNAL_POLICY_DOWNLOAD);
+  ASSERT_EQ(0, Manifest::INVALID_LOCATION);
+  ASSERT_EQ(1, Manifest::INTERNAL);
+  ASSERT_EQ(2, Manifest::EXTERNAL_PREF);
+  ASSERT_EQ(3, Manifest::EXTERNAL_REGISTRY);
+  ASSERT_EQ(4, Manifest::LOAD);
+  ASSERT_EQ(5, Manifest::COMPONENT);
+  ASSERT_EQ(6, Manifest::EXTERNAL_PREF_DOWNLOAD);
+  ASSERT_EQ(7, Manifest::EXTERNAL_POLICY_DOWNLOAD);
 }
 
 TEST_F(ExtensionTest, LocationPriorityTest) {
-  for (int i = 0; i < Extension::NUM_LOCATIONS; i++) {
-    Extension::Location loc = static_cast<Extension::Location>(i);
+  for (int i = 0; i < Manifest::NUM_LOCATIONS; i++) {
+    Manifest::Location loc = static_cast<Manifest::Location>(i);
 
     // INVALID is not a valid location.
-    if (loc == Extension::INVALID)
+    if (loc == Manifest::INVALID_LOCATION)
       continue;
 
     // Comparing a location that has no rank will hit a CHECK. Do a
     // compare with every valid location, to be sure each one is covered.
 
     // Check that no install source can override a componenet extension.
-    ASSERT_EQ(Extension::COMPONENT,
-              Extension::GetHigherPriorityLocation(Extension::COMPONENT, loc));
-    ASSERT_EQ(Extension::COMPONENT,
-              Extension::GetHigherPriorityLocation(loc, Extension::COMPONENT));
+    ASSERT_EQ(Manifest::COMPONENT,
+              Manifest::GetHigherPriorityLocation(Manifest::COMPONENT, loc));
+    ASSERT_EQ(Manifest::COMPONENT,
+              Manifest::GetHigherPriorityLocation(loc, Manifest::COMPONENT));
 
     // Check that any source can override a user install. This might change
     // in the future, in which case this test should be updated.
     ASSERT_EQ(loc,
-              Extension::GetHigherPriorityLocation(Extension::INTERNAL, loc));
+              Manifest::GetHigherPriorityLocation(Manifest::INTERNAL, loc));
     ASSERT_EQ(loc,
-              Extension::GetHigherPriorityLocation(loc, Extension::INTERNAL));
+              Manifest::GetHigherPriorityLocation(loc, Manifest::INTERNAL));
   }
 
   // Check a few interesting cases that we know can happen:
-  ASSERT_EQ(Extension::EXTERNAL_POLICY_DOWNLOAD,
-            Extension::GetHigherPriorityLocation(
-                Extension::EXTERNAL_POLICY_DOWNLOAD,
-                Extension::EXTERNAL_PREF));
+  ASSERT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD,
+            Manifest::GetHigherPriorityLocation(
+                Manifest::EXTERNAL_POLICY_DOWNLOAD,
+                Manifest::EXTERNAL_PREF));
 
-  ASSERT_EQ(Extension::EXTERNAL_PREF,
-            Extension::GetHigherPriorityLocation(
-                Extension::INTERNAL,
-                Extension::EXTERNAL_PREF));
+  ASSERT_EQ(Manifest::EXTERNAL_PREF,
+            Manifest::GetHigherPriorityLocation(
+                Manifest::INTERNAL,
+                Manifest::EXTERNAL_PREF));
 }
 
 TEST_F(ExtensionTest, GetResourceURLAndPath) {
   scoped_refptr<Extension> extension = LoadManifestStrict("empty_manifest",
       "empty.json");
   EXPECT_TRUE(extension.get());
 
   EXPECT_EQ(extension->url().spec() + "bar/baz.js",
             Extension::GetResourceURL(extension->url(), "bar/baz.js").spec());
   EXPECT_EQ(extension->url().spec() + "baz.js",
             Extension::GetResourceURL(extension->url(),
                                       "bar/../baz.js").spec());
   EXPECT_EQ(extension->url().spec() + "baz.js",
             Extension::GetResourceURL(extension->url(), "../baz.js").spec());
 
   // Test that absolute-looking paths ("/"-prefixed) are pasted correctly.
   EXPECT_EQ(extension->url().spec() + "test.html",
             extension->GetResourceURL("/test.html").spec());
 }
 
 TEST_F(ExtensionTest, GetAbsolutePathNoError) {
   scoped_refptr<Extension> extension = LoadManifestStrict("absolute_path",
       "absolute.json");
   EXPECT_TRUE(extension.get());
   std::string err;
-  Extension::InstallWarningVector warnings;
+  std::vector<InstallWarning> warnings;
   EXPECT_TRUE(extension_file_util::ValidateExtension(extension.get(),
                                                      &err, &warnings));
   EXPECT_EQ(0U, warnings.size());
 
   EXPECT_EQ(extension->path().AppendASCII("test.html").value(),
             extension->GetResource("test.html").GetFilePath().value());
   EXPECT_EQ(extension->path().AppendASCII("test.js").value(),
             extension->GetResource("test.js").GetFilePath().value());
 }
 
@@ skipping 250 matching lines @@
       chrome::VersionInfo::CHANNEL_DEV);
   scoped_refptr<Extension> extension;
   std::string error;
 
   extension = LoadManifest("socket_permissions", "empty.json");
   EXPECT_FALSE(CheckSocketPermission(extension,
       SocketPermissionRequest::TCP_CONNECT, "www.example.com", 80));
 
   extension = LoadManifestUnchecked("socket_permissions",
                                     "socket1.json",
-                                    Extension::INTERNAL, Extension::NO_FLAGS,
+                                    Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension == NULL);
   ASSERT_EQ(ErrorUtils::FormatErrorMessage(
         errors::kInvalidPermission, "socket"), error);
 
   extension = LoadManifest("socket_permissions", "socket2.json");
   EXPECT_TRUE(CheckSocketPermission(extension,
       SocketPermissionRequest::TCP_CONNECT, "www.example.com", 80));
   EXPECT_FALSE(CheckSocketPermission(
         extension, SocketPermissionRequest::UDP_BIND, "", 80));
@@ skipping 24 matching lines @@
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions");
 
   // Initialize the Extension.
   std::string errors;
   DictionaryValue values;
   values.SetString(keys::kName, "test");
   values.SetString(keys::kVersion, "0.1");
   scoped_refptr<Extension> extension(Extension::Create(
-      path, Extension::INVALID, values, Extension::NO_FLAGS, &errors));
+      path, Manifest::INVALID_LOCATION, values, Extension::NO_FLAGS, &errors));
   ASSERT_TRUE(extension.get());
 
   // Create an ExtensionResource pointing at an icon.
   FilePath icon_relative_path(FILE_PATH_LITERAL("icon3.png"));
   ExtensionResource resource(extension->id(),
                              extension->path(),
                              icon_relative_path);
 
   // Read in the icon file.
   FilePath icon_absolute_path = extension->path().Append(icon_relative_path);
@@ skipping 365 matching lines @@
   EXPECT_TRUE(Blocked(extension, favicon_url));
   extension = LoadManifest("script_and_capture",
       "extension_wildcard_settings.json");
   EXPECT_TRUE(Blocked(extension, settings_url));
 
   // Having chrome://*/ should not work for regular extensions. Note that
   // for favicon access, we require the explicit pattern chrome://favicon/*.
   std::string error;
   extension = LoadManifestUnchecked("script_and_capture",
                                     "extension_wildcard_chrome.json",
-                                    Extension::INTERNAL, Extension::NO_FLAGS,
+                                    Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension == NULL);
   EXPECT_EQ(ErrorUtils::FormatErrorMessage(
       errors::kInvalidPermissionScheme, "chrome://*/"), error);
 
   // Having chrome://favicon/* should not give you chrome://*
   extension = LoadManifestStrict("script_and_capture",
       "extension_chrome_favicon_wildcard.json");
   EXPECT_TRUE(Blocked(extension, settings_url));
   EXPECT_TRUE(CaptureOnly(extension, favicon_url));
   EXPECT_TRUE(Blocked(extension, about_url));
   EXPECT_TRUE(extension->HasHostPermission(favicon_url));
 
   // Having http://favicon should not give you chrome://favicon
   extension = LoadManifestStrict("script_and_capture",
       "extension_http_favicon.json");
   EXPECT_TRUE(Blocked(extension, settings_url));
   EXPECT_TRUE(Blocked(extension, favicon_url));
 
   // Component extensions with <all_urls> should get everything.
   extension = LoadManifest("script_and_capture", "extension_component_all.json",
-      Extension::COMPONENT, Extension::NO_FLAGS);
+      Manifest::COMPONENT, Extension::NO_FLAGS);
   EXPECT_TRUE(Allowed(extension, http_url));
   EXPECT_TRUE(Allowed(extension, https_url));
   EXPECT_TRUE(Allowed(extension, settings_url));
   EXPECT_TRUE(Allowed(extension, about_url));
   EXPECT_TRUE(Allowed(extension, favicon_url));
   EXPECT_TRUE(extension->HasHostPermission(favicon_url));
 
   // Component extensions should only get access to what they ask for.
   extension = LoadManifest("script_and_capture",
-      "extension_component_google.json", Extension::COMPONENT,
+      "extension_component_google.json", Manifest::COMPONENT,
       Extension::NO_FLAGS);
   EXPECT_TRUE(Allowed(extension, http_url));
   EXPECT_TRUE(Blocked(extension, https_url));
   EXPECT_TRUE(Blocked(extension, file_url));
   EXPECT_TRUE(Blocked(extension, settings_url));
   EXPECT_TRUE(Blocked(extension, favicon_url));
   EXPECT_TRUE(Blocked(extension, about_url));
   EXPECT_TRUE(Blocked(extension, extension_url));
   EXPECT_FALSE(extension->HasHostPermission(settings_url));
 }
@@ skipping 101 matching lines @@
   EXTENSION,
   APP,
   USER_SCRIPT,
   THEME
 };
 
 static scoped_refptr<Extension> MakeSyncTestExtension(
     SyncTestExtensionType type,
     const GURL& update_url,
     const GURL& launch_url,
-    Extension::Location location,
+    Manifest::Location location,
     int num_plugins,
     const FilePath& extension_path,
     int creation_flags) {
   DictionaryValue source;
   source.SetString(extension_manifest_keys::kName,
                    "PossiblySyncableExtension");
   source.SetString(extension_manifest_keys::kVersion, "0.0.0.0");
   if (type == APP)
     source.SetString(extension_manifest_keys::kApp, "true");
   if (type == THEME)
@@ skipping 28 matching lines @@
 
 static const char kValidUpdateUrl1[] =
     "http://clients2.google.com/service/update2/crx";
 static const char kValidUpdateUrl2[] =
     "https://clients2.google.com/service/update2/crx";
 }
 
 TEST_F(ExtensionTest, GetSyncTypeNormalExtensionNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 // http://crbug.com/172712
 TEST_F(ExtensionTest, DISABLED_GetSyncTypeUserScriptValidUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(USER_SCRIPT, GURL(kValidUpdateUrl1), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeUserScriptNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(USER_SCRIPT, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeThemeNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(THEME, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeExtensionWithLaunchUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL("http://www.google.com"),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeExtensionExternal) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::EXTERNAL_PREF, 0, FilePath(),
+                            Manifest::EXTERNAL_PREF, 0, FilePath(),
                             Extension::NO_FLAGS));
 
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeUserScriptThirdPartyUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(
           USER_SCRIPT, GURL("http://third-party.update_url.com"), GURL(),
-          Extension::INTERNAL, 0, FilePath(), Extension::NO_FLAGS));
+          Manifest::INTERNAL, 0, FilePath(), Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, OnlyDisplayAppsInLauncher) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
 
   EXPECT_FALSE(extension->ShouldDisplayInAppLauncher());
   EXPECT_FALSE(extension->ShouldDisplayInNewTabPage());
 
   scoped_refptr<Extension> app(
       MakeSyncTestExtension(APP, GURL(), GURL("http://www.google.com"),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_TRUE(app->ShouldDisplayInAppLauncher());
   EXPECT_TRUE(app->ShouldDisplayInNewTabPage());
 }
 
 TEST_F(ExtensionTest, DisplayInXManifestProperties) {
   DictionaryValue manifest;
   manifest.SetString(keys::kName, "TestComponentApp");
   manifest.SetString(keys::kVersion, "0.0.0.0");
   manifest.SetString(keys::kApp, "true");
   manifest.SetString(keys::kPlatformAppBackgroundPage, "");
 
   std::string error;
   scoped_refptr<Extension> app;
 
   // Default to true.
   app = Extension::Create(
-      FilePath(), Extension::COMPONENT, manifest, 0, &error);
+      FilePath(), Manifest::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string());
   EXPECT_TRUE(app->ShouldDisplayInAppLauncher());
   EXPECT_TRUE(app->ShouldDisplayInNewTabPage());
 
   // Value display_in_NTP defaults to display_in_launcher.
   manifest.SetBoolean(keys::kDisplayInLauncher, false);
   app = Extension::Create(
-      FilePath(), Extension::COMPONENT, manifest, 0, &error);
+      FilePath(), Manifest::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string());
   EXPECT_FALSE(app->ShouldDisplayInAppLauncher());
   EXPECT_FALSE(app->ShouldDisplayInNewTabPage());
 
   // Value display_in_NTP = true overriding display_in_launcher = false.
   manifest.SetBoolean(keys::kDisplayInNewTabPage, true);
   app = Extension::Create(
-      FilePath(), Extension::COMPONENT, manifest, 0, &error);
+      FilePath(), Manifest::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string());
   EXPECT_FALSE(app->ShouldDisplayInAppLauncher());
   EXPECT_TRUE(app->ShouldDisplayInNewTabPage());
 
   // Value display_in_NTP = false only, overrides default = true.
   manifest.Remove(keys::kDisplayInLauncher, NULL);
   manifest.SetBoolean(keys::kDisplayInNewTabPage, false);
   app = Extension::Create(
-      FilePath(), Extension::COMPONENT, manifest, 0, &error);
+      FilePath(), Manifest::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string());
   EXPECT_TRUE(app->ShouldDisplayInAppLauncher());
   EXPECT_FALSE(app->ShouldDisplayInNewTabPage());
 
   // Error checking.
   manifest.SetString(keys::kDisplayInNewTabPage, "invalid");
   app = Extension::Create(
-      FilePath(), Extension::COMPONENT, manifest, 0, &error);
+      FilePath(), Manifest::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string(errors::kInvalidDisplayInNewTabPage));
 }
 
 TEST_F(ExtensionTest, OnlySyncInternal) {
   scoped_refptr<Extension> extension_internal(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_TRUE(extension_internal->IsSyncable());
 
   scoped_refptr<Extension> extension_noninternal(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::COMPONENT, 0, FilePath(),
+                            Manifest::COMPONENT, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_FALSE(extension_noninternal->IsSyncable());
 }
 
 TEST_F(ExtensionTest, DontSyncDefault) {
   scoped_refptr<Extension> extension_default(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 0, FilePath(),
+                            Manifest::INTERNAL, 0, FilePath(),
                             Extension::WAS_INSTALLED_BY_DEFAULT));
   EXPECT_FALSE(extension_default->IsSyncable());
 }
 
 TEST_F(ExtensionTest, OptionalOnlyPermission) {
   // Set feature current channel to dev because the only permission that must
   // be optional (usbDevices) is only available on dev channel.
   Feature::ScopedCurrentChannel scoped_channel(
       chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension;
   std::string error;
   extension = LoadManifestUnchecked("optional_only_permission",
                                     "manifest1.json",
-                                    Extension::INTERNAL, Extension::NO_FLAGS,
+                                    Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension == NULL);
   ASSERT_EQ(ErrorUtils::FormatErrorMessage(
         errors::kPermissionMustBeOptional, "usbDevices"), error);
 
   error.clear();
   extension = LoadManifestUnchecked("optional_only_permission",
                                     "manifest2.json",
-                                    Extension::INTERNAL, Extension::NO_FLAGS,
+                                    Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension != NULL);
   EXPECT_TRUE(error.empty());
 }
 
 // These last 2 tests don't make sense on Chrome OS, where extension plugins
 // are not allowed.
 #if !defined(OS_CHROMEOS)
 TEST_F(ExtensionTest, GetSyncTypeExtensionWithPlugin) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 1, FilePath(),
+                            Manifest::INTERNAL, 1, FilePath(),
                             Extension::NO_FLAGS));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
 TEST_F(ExtensionTest, GetSyncTypeExtensionWithTwoPlugins) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
-                            Extension::INTERNAL, 2, FilePath(),
+                            Manifest::INTERNAL, 2, FilePath(),
                             Extension::NO_FLAGS));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 #endif // !defined(OS_CHROMEOS)
 
 }  // namespace extensions