Replace bools in extension creation with flags.

chrome/common/extensions/extension_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
 #include "base/format_macros.h"
@@ skipping 86 matching lines @@
       .AppendASCII("1.0.0.0")
       .Append(Extension::kManifestFilename);
 
   JSONFileValueSerializer serializer(extensions_path);
   scoped_ptr<DictionaryValue> valid_value(
       static_cast<DictionaryValue*>(serializer.Deserialize(&error_code,
                                                            &error)));
   EXPECT_EQ("", error);
   EXPECT_EQ(0, error_code);
   ASSERT_TRUE(valid_value.get());
-  ASSERT_TRUE(extension.InitFromValue(*valid_value, true, false, &error));
+  ASSERT_TRUE(extension.InitFromValue(*valid_value, Extension::REQUIRE_KEY,
+                                      &error));
   ASSERT_EQ("", error);
   EXPECT_EQ("en_US", extension.default_locale());
 
   scoped_ptr<DictionaryValue> input_value;
 
   // Test missing and invalid versions
   input_value.reset(valid_value->DeepCopy());
   input_value->Remove(keys::kVersion, NULL);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidVersion, error);
 
   input_value->SetInteger(keys::kVersion, 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidVersion, error);
 
   // Test missing and invalid names.
   input_value.reset(valid_value->DeepCopy());
   input_value->Remove(keys::kName, NULL);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidName, error);
 
   input_value->SetInteger(keys::kName, 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidName, error);
 
   // Test invalid description
   input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kDescription, 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidDescription, error);
 
   // Test invalid icons
   input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kIcons, 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidIcons, error);
 
   // Test invalid icon paths
   input_value.reset(valid_value->DeepCopy());
   DictionaryValue* icons = NULL;
   input_value->GetDictionary(keys::kIcons, &icons);
   ASSERT_FALSE(NULL == icons);
   icons->SetInteger(base::IntToString(128), 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidIconPath));
 
   // Test invalid user scripts list
   input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kContentScripts, 42);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_EQ(errors::kInvalidContentScriptsList, error);
 
   // Test invalid user script item
   input_value.reset(valid_value->DeepCopy());
   ListValue* content_scripts = NULL;
   input_value->GetList(keys::kContentScripts, &content_scripts);
   ASSERT_FALSE(NULL == content_scripts);
   content_scripts->Set(0, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidContentScript));
 
   // Test missing and invalid matches array
   input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kContentScripts, &content_scripts);
   DictionaryValue* user_script = NULL;
   content_scripts->GetDictionary(0, &user_script);
   user_script->Remove(keys::kMatches, NULL);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatches));
 
   user_script->Set(keys::kMatches, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatches));
 
   ListValue* matches = new ListValue;
   user_script->Set(keys::kMatches, matches);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatchCount));
 
   // Test invalid match element
   matches->Set(0, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatch));
 
   matches->Set(0, Value::CreateStringValue("chrome://*/*"));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatch));
 
   // Test missing and invalid files array
   input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kContentScripts, &content_scripts);
   content_scripts->GetDictionary(0, &user_script);
   user_script->Remove(keys::kJs, NULL);
   user_script->Remove(keys::kCss, NULL);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kMissingFile));
 
   user_script->Set(keys::kJs, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidJsList));
 
   user_script->Set(keys::kCss, new ListValue);
   user_script->Set(keys::kJs, new ListValue);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kMissingFile));
   user_script->Remove(keys::kCss, NULL);
 
   ListValue* files = new ListValue;
   user_script->Set(keys::kJs, files);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kMissingFile));
 
   // Test invalid file element
   files->Set(0, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidJs));
 
   user_script->Remove(keys::kJs, NULL);
   // Test the css element
   user_script->Set(keys::kCss, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidCssList));
 
   // Test invalid file element
   ListValue* css_files = new ListValue;
   user_script->Set(keys::kCss, css_files);
   css_files->Set(0, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidCss));
 
   // Test missing and invalid permissions array
   input_value.reset(valid_value->DeepCopy());
-  EXPECT_TRUE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                      &error));
 
   ListValue* permissions = NULL;
   input_value->GetList(keys::kPermissions, &permissions);
   ASSERT_FALSE(NULL == permissions);
 
   permissions = new ListValue;
   input_value->Set(keys::kPermissions, permissions);
-  EXPECT_TRUE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                      &error));
 
   input_value->Set(keys::kPermissions, Value::CreateIntegerValue(9));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermissions));
 
   input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kPermissions, &permissions);
   permissions->Set(0, Value::CreateIntegerValue(24));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermission));
 
   // We allow unknown API permissions, so this will be valid until we better
   // distinguish between API and host permissions.
   permissions->Set(0, Value::CreateStringValue("www.google.com"));
-  EXPECT_TRUE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                      &error));
 
   // Multiple page actions are not allowed.
   input_value.reset(valid_value->DeepCopy());
   DictionaryValue* action = new DictionaryValue;
   action->SetString(keys::kPageActionId, "MyExtensionActionId");
   action->SetString(keys::kName, "MyExtensionActionName");
   ListValue* action_list = new ListValue;
   action_list->Append(action->DeepCopy());
   action_list->Append(action);
   input_value->Set(keys::kPageActions, action_list);
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_STREQ(errors::kInvalidPageActionsListSize, error.c_str());
 
   // Test invalid options page url.
   input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kOptionsPage, Value::CreateNullValue());
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidOptionsPage));
 
   // Test invalid/empty default locale.
   input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kDefaultLocale, Value::CreateIntegerValue(5));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidDefaultLocale));
 
   input_value->Set(keys::kDefaultLocale, Value::CreateStringValue(""));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidDefaultLocale));
 
   // Test invalid minimum_chrome_version.
   input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kMinimumChromeVersion, Value::CreateIntegerValue(42));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMinimumChromeVersion));
 
 #if !defined(OS_MACOSX)
   // TODO(aa): The version isn't stamped into the unit test binary on mac.
   input_value->Set(keys::kMinimumChromeVersion,
                    Value::CreateStringValue("88.8"));
-  EXPECT_FALSE(extension.InitFromValue(*input_value, true, false, &error));
+  EXPECT_FALSE(extension.InitFromValue(*input_value, Extension::REQUIRE_KEY,
+                                       &error));
   EXPECT_TRUE(MatchPattern(error, errors::kChromeVersionTooLow));
 #endif
 }
 
 TEST(ExtensionTest, InitFromValueValid) {
 #if defined(OS_WIN)
   FilePath path(FILE_PATH_LITERAL("C:\\foo"));
 #elif defined(OS_POSIX)
   FilePath path(FILE_PATH_LITERAL("/foo"));
 #endif
   scoped_refptr<Extension> extension_ptr(new Extension(path,
                                                        Extension::INVALID));
   Extension& extension = *extension_ptr;
   std::string error;
   DictionaryValue input_value;
 
   // Test minimal extension
   input_value.SetString(keys::kVersion, "1.0.0.0");
   input_value.SetString(keys::kName, "my extension");
 
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
   EXPECT_TRUE(Extension::IdIsValid(extension.id()));
   EXPECT_EQ("1.0.0.0", extension.VersionString());
   EXPECT_EQ("my extension", extension.name());
   EXPECT_EQ(extension.id(), extension.url().host());
   EXPECT_EQ(path.value(), extension.path().value());
 
   // Test permissions scheme.
   ListValue* permissions = new ListValue;
   permissions->Set(0, Value::CreateStringValue("file:///C:/foo.txt"));
   input_value.Set(keys::kPermissions, permissions);
 
   // We allow unknown API permissions, so this will be valid until we better
   // distinguish between API and host permissions.
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   input_value.Remove(keys::kPermissions, NULL);
 
   // Test with an options page.
   input_value.SetString(keys::kOptionsPage, "options.html");
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
   EXPECT_EQ("chrome-extension", extension.options_url().scheme());
   EXPECT_EQ("/options.html", extension.options_url().path());
 
   // Test that an empty list of page actions does not stop a browser action
   // from being loaded.
   ListValue* empty_list = new ListValue;
   input_value.Set(keys::kPageActions, empty_list);
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
 
 #if !defined(OS_MACOSX)
   // TODO(aa): The version isn't stamped into the unit test binary on mac.
   // Test with a minimum_chrome_version.
   input_value.SetString(keys::kMinimumChromeVersion, "1.0");
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
   // The minimum chrome version is not stored in the Extension object.
 #endif
 }
 
 TEST(ExtensionTest, InitFromValueValidNameInRTL) {
 #if defined(TOOLKIT_GTK)
   GtkTextDirection gtk_dir = gtk_widget_get_default_direction();
   gtk_widget_set_default_direction(GTK_TEXT_DIR_RTL);
 #else
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 #endif
 
 #if defined(OS_WIN)
   FilePath path(FILE_PATH_LITERAL("C:\\foo"));
 #elif defined(OS_POSIX)
   FilePath path(FILE_PATH_LITERAL("/foo"));
 #endif
   scoped_refptr<Extension> extension_ptr(new Extension(path,
                                                        Extension::INVALID));
   Extension& extension = *extension_ptr;
   std::string error;
   DictionaryValue input_value;
 
   input_value.SetString(keys::kVersion, "1.0.0.0");
   // No strong RTL characters in name.
   std::wstring name(L"Dictionary (by Google)");
   input_value.SetString(keys::kName, WideToUTF16Hack(name));
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
   std::wstring localized_name(name);
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
   EXPECT_EQ(localized_name, UTF8ToWide(extension.name()));
 
   // Strong RTL characters in name.
   name = L"Dictionary (\x05D1\x05D2"L" Google)";
   input_value.SetString(keys::kName, WideToUTF16Hack(name));
-  EXPECT_TRUE(extension.InitFromValue(input_value, false, false, &error));
+  EXPECT_TRUE(extension.InitFromValue(input_value, Extension::NO_FLAGS,
+                                      &error));
   EXPECT_EQ("", error);
   localized_name = name;
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
   EXPECT_EQ(localized_name, UTF8ToWide(extension.name()));
 
   // Reset locale.
 #if defined(TOOLKIT_GTK)
   gtk_widget_set_default_direction(gtk_dir);
 #else
   base::i18n::SetICUDefaultLocale(locale);
 #endif
 }
 
 TEST(ExtensionTest, GetResourceURLAndPath) {
 #if defined(OS_WIN)
   FilePath path(FILE_PATH_LITERAL("C:\\foo"));
 #elif defined(OS_POSIX)
   FilePath path(FILE_PATH_LITERAL("/foo"));
 #endif
   DictionaryValue input_value;
   input_value.SetString(keys::kVersion, "1.0.0.0");
   input_value.SetString(keys::kName, "my extension");
-  scoped_refptr<Extension> extension(Extension::Create(
-      path, Extension::INVALID, input_value, false, true, NULL));
+  scoped_refptr<Extension> extension(Extension::Create(path,
+      Extension::INVALID, input_value, Extension::STRICT_ERROR_CHECKS, NULL));
   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());
 }
@@ skipping 238 matching lines @@
 #else
     FilePath path(base::StringPrintf("/extension%" PRIuS, i));
 #endif
     std::string error;
 
     input_value.SetString(keys::kVersion, "1.0");
     input_value.SetString(keys::kName, "Test");
     input_value.SetString(keys::kUpdateURL, url.spec());
 
     scoped_refptr<Extension> extension(Extension::Create(
-        path, Extension::INVALID, input_value, false, true, &error));
+        path, Extension::INVALID, input_value, Extension::STRICT_ERROR_CHECKS,
+        &error));
     EXPECT_TRUE(extension.get()) << error;
   }
 
   // Test some invalid update urls
   std::vector<std::string> invalid;
   invalid.push_back("");
   invalid.push_back("test.com");
   valid.push_back("http://test.com/update#whatever");
   for (size_t i = 0; i < invalid.size(); i++) {
     DictionaryValue input_value;
 #if defined(OS_WIN)
     // (Why %Iu below?  This is the single file in the whole code base that
     // might make use of a WidePRIuS; let's not encourage any more.)
     FilePath path(base::StringPrintf(L"c:\\extension%Iu", i));
 #else
     FilePath path(base::StringPrintf("/extension%" PRIuS, i));
 #endif
     std::string error;
     input_value.SetString(keys::kVersion, "1.0");
     input_value.SetString(keys::kName, "Test");
     input_value.SetString(keys::kUpdateURL, invalid[i]);
 
     scoped_refptr<Extension> extension(Extension::Create(
-        path, Extension::INVALID, input_value, false, true, &error));
+        path, Extension::INVALID, input_value, Extension::STRICT_ERROR_CHECKS,
+        &error));
     EXPECT_FALSE(extension.get());
     EXPECT_TRUE(MatchPattern(error, errors::kInvalidUpdateURL));
   }
 }
 
 // This test ensures that the mimetype sniffing code stays in sync with the
 // actual crx files that we test other parts of the system with.
 TEST(ExtensionTest, MimeTypeSniffing) {
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
@@ skipping 27 matching lines @@
   JSONFileValueSerializer serializer(path);
   std::string error;
   scoped_ptr<Value> result(serializer.Deserialize(NULL, &error));
   if (!result.get()) {
     EXPECT_EQ("", error);
     return NULL;
   }
 
   scoped_refptr<Extension> extension = Extension::Create(
       path.DirName(), Extension::INVALID,
-      *static_cast<DictionaryValue*>(result.get()), false, true, &error);
+      *static_cast<DictionaryValue*>(result.get()),
+      Extension::STRICT_ERROR_CHECKS, &error);
   EXPECT_TRUE(extension) << error;
   return extension;
 }
 
 TEST(ExtensionTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
   ExtensionExtent hosts;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
   EXPECT_EQ(0u, extension->GetEffectiveHostPermissions().patterns().size());
@@ skipping 206 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, false, true, &errors));
+      path, Extension::INVALID, values, Extension::STRICT_ERROR_CHECKS,
+      &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 63 matching lines @@
   ListValue* permissions = new ListValue();
   const char* old_unlimited = "unlimited_storage";
   EXPECT_STREQ(old_unlimited, Extension::kOldUnlimitedStoragePermission);
   permissions->Append(Value::CreateStringValue(old_unlimited));
   dictionary.Set(extension_manifest_keys::kPermissions, permissions);
 
   // Initialize the extension and make sure the permission for unlimited storage
   // is present.
   std::string errors;
   scoped_refptr<Extension> extension(Extension::Create(
-      extension_path, Extension::INVALID, dictionary, false, true, &errors));
+      extension_path, Extension::INVALID, dictionary,
+      Extension::STRICT_ERROR_CHECKS, &errors));
   EXPECT_TRUE(extension.get());
   EXPECT_TRUE(extension->HasApiPermission(
       Extension::kUnlimitedStoragePermission));
 }
 
 // This tests the API permissions with an empty manifest (one that just
 // specifies a name and a version and nothing else).
 TEST(ExtensionTest, ApiPermissions) {
   const struct {
     const char* permission_name;
@@ skipping 301 matching lines @@
   EXPECT_TRUE(Extension::GenerateId("test", &result));
   EXPECT_EQ(result, "jpignaibiiemhngfjkcpokkamffknabf");
 
   EXPECT_TRUE(Extension::GenerateId("_", &result));
   EXPECT_EQ(result, "ncocknphbhhlhkikpnnlmbcnbgdempcd");
 
   EXPECT_TRUE(Extension::GenerateId(
       "this_string_is_longer_than_a_single_sha256_hash_digest", &result));
   EXPECT_EQ(result, "jimneklojkjdibfkgiiophfhjhbdgcfi");
 }