Allow webstore extensions to use experimental permissions.

chrome/common/extensions/extension_manifests_unittest.cc

 // 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
 
@@ skipping 30 matching lines @@
 }
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 class ExtensionManifestTest : public testing::Test {
  public:
   ExtensionManifestTest() : enable_apps_(true) {}
 
  protected:
-  DictionaryValue* LoadManifestFile(const std::string& filename,
-                                    std::string* error) {
+  static DictionaryValue* LoadManifestFile(const std::string& filename,
+                                           std::string* error) {
     FilePath path;
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("extensions")
         .AppendASCII("manifest_tests")
         .AppendASCII(filename.c_str());
     EXPECT_TRUE(file_util::PathExists(path));
 
     JSONFileValueSerializer serializer(path);
     return static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
   }
 
-  scoped_refptr<Extension> LoadExtensionWithLocation(
-      DictionaryValue* value,
-      Extension::Location location,
-      bool strict_error_checks,
-      std::string* error) {
+  // Helper class that simplifies creating methods that take either a filename
+  // to a manifest or the manifest itself.
+  class Manifest {
+   public:
+    // Purposely not marked explicit for convenience. The vast majority of
+    // callers pass string literal.
+    Manifest(const char* name)
+        : name_(name), manifest_(NULL) {
+    }
+    Manifest(DictionaryValue* manifest, const char* name)
+        : name_(name), manifest_(manifest) {
+    }
+
+    const std::string& name() const { return name_; }
+
+    DictionaryValue* GetManifest(std::string* error) const {
+      if (manifest_)
+        return manifest_;
+
+      manifest_ = LoadManifestFile(name_, error);
+      manifest_holder_.reset(manifest_);
+      return manifest_;
+    }
+
+   private:
+    std::string name_;
+    mutable DictionaryValue* manifest_;
+    mutable scoped_ptr<DictionaryValue> manifest_holder_;
+  };
+
+  scoped_refptr<Extension> LoadExtension(
+      const Manifest& manifest,
+      std::string* error,
+      Extension::Location location = Extension::INTERNAL,
+      int flags = Extension::NO_FLAGS) {
+    DictionaryValue* value = manifest.GetManifest(error);
+    if (!value)
+      return NULL;
     FilePath path;
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("extensions").AppendASCII("manifest_tests");
-    int flags = Extension::NO_FLAGS;
-    if (strict_error_checks)
-      flags |= Extension::STRICT_ERROR_CHECKS;
     return Extension::Create(path.DirName(), location, *value, flags, error);
   }
 
-  scoped_refptr<Extension> LoadExtension(const std::string& name,
-                                         std::string* error) {
-    return LoadExtensionWithLocation(name, Extension::INTERNAL, false, error);
-  }
-
-  scoped_refptr<Extension> LoadExtensionStrict(const std::string& name,
-                                               std::string* error) {
-    return LoadExtensionWithLocation(name, Extension::INTERNAL, true, error);
-  }
-
-  scoped_refptr<Extension> LoadExtension(DictionaryValue* value,
-                                         std::string* error) {
-    // Loading as an installed extension disables strict error checks.
-    return LoadExtensionWithLocation(value, Extension::INTERNAL, false, error);
-  }
-
-  scoped_refptr<Extension> LoadExtensionWithLocation(
-      const std::string& name,
-      Extension::Location location,
-      bool strict_error_checks,
-      std::string* error) {
-    scoped_ptr<DictionaryValue> value(LoadManifestFile(name, error));
-    if (!value.get())
-      return NULL;
-    return LoadExtensionWithLocation(value.get(), location,
-                                     strict_error_checks, error);
-  }
-
-  scoped_refptr<Extension> LoadAndExpectSuccess(const std::string& name) {
+  scoped_refptr<Extension> LoadAndExpectSuccess(
+      const Manifest& manifest,
+      Extension::Location location = Extension::INTERNAL,
+      int flags = Extension::NO_FLAGS) {
     std::string error;
-    scoped_refptr<Extension> extension = LoadExtension(name, &error);
-    EXPECT_TRUE(extension) << name;
-    EXPECT_EQ("", error) << name;
+    scoped_refptr<Extension> extension =
+        LoadExtension(manifest, &error, location, flags);
+    EXPECT_TRUE(extension) << manifest.name();
+    EXPECT_EQ("", error) << manifest.name();
     return extension;
   }
 
-  scoped_refptr<Extension> LoadStrictAndExpectSuccess(const std::string& name) {
-    std::string error;
-    scoped_refptr<Extension> extension = LoadExtensionStrict(name, &error);
-    EXPECT_TRUE(extension) << name;
-    EXPECT_EQ("", error) << name;
-    return extension;
-  }
-
-  scoped_refptr<Extension> LoadAndExpectSuccess(DictionaryValue* manifest,
-                                                const std::string& name) {
-    std::string error;
-    scoped_refptr<Extension> extension = LoadExtension(manifest, &error);
-    EXPECT_TRUE(extension) << "Unexpected failure for " << name;
-    EXPECT_EQ("", error) << "Unexpected error for " << name;
-    return extension;
-  }
-
   void VerifyExpectedError(Extension* extension,
                            const std::string& name,
                            const std::string& error,
                            const std::string& expected_error) {
     EXPECT_FALSE(extension) <<
         "Expected failure loading extension '" << name <<
         "', but didn't get one.";
     EXPECT_TRUE(MatchPattern(error, expected_error)) << name <<
         " expected '" << expected_error << "' but got '" << error << "'";
   }
 
-  void LoadAndExpectError(const std::string& name,
-                          const std::string& expected_error) {
+  void LoadAndExpectError(const Manifest& manifest,
+                          const std::string& expected_error,
+                          Extension::Location location = Extension::INTERNAL,
+                          int flags = Extension::NO_FLAGS) {
     std::string error;
-    scoped_refptr<Extension> extension(LoadExtension(name, &error));
-    VerifyExpectedError(extension.get(), name, error, expected_error);
-  }
-
-  void LoadAndExpectErrorStrict(const std::string& name,
-                                const std::string& expected_error) {
-    std::string error;
-    scoped_refptr<Extension> extension(LoadExtensionStrict(name, &error));
-    VerifyExpectedError(extension.get(), name, error, expected_error);
-  }
-
-  void LoadAndExpectError(DictionaryValue* manifest,
-                          const std::string& name,
-                          const std::string& expected_error) {
-    std::string error;
-    scoped_refptr<Extension> extension(LoadExtension(manifest, &error));
-    VerifyExpectedError(extension.get(), name, error, expected_error);
+    scoped_refptr<Extension> extension(
+        LoadExtension(manifest, &error, location, flags));
+    VerifyExpectedError(extension.get(), manifest.name(), error,
+                        expected_error);
   }
 
   struct Testcase {
     std::string manifest;
     std::string expected_error;
   };
 
   void RunTestcases(const Testcase* testcases, size_t num_testcases) {
     for (size_t i = 0; i < num_testcases; ++i) {
-      LoadAndExpectError(testcases[i].manifest, testcases[i].expected_error);
+      LoadAndExpectError(testcases[i].manifest.c_str(),
+                         testcases[i].expected_error);
     }
   }
 
   bool enable_apps_;
 };
 
 TEST_F(ExtensionManifestTest, InitFromValueInvalid) {
   Testcase testcases[] = {
     {"init_invalid_version_missing.json", errors::kInvalidVersion},
     {"init_invalid_version_invalid.json", errors::kInvalidVersion},
@@ skipping 106 matching lines @@
   // Reset locale.
 #if defined(TOOLKIT_GTK)
   gtk_widget_set_default_direction(gtk_dir);
 #else
   base::i18n::SetICUDefaultLocale(locale);
 #endif
 }
 
 TEST_F(ExtensionManifestTest, UpdateUrls) {
   // Test several valid update urls
-  LoadStrictAndExpectSuccess("update_url_valid_1.json");
-  LoadStrictAndExpectSuccess("update_url_valid_2.json");
-  LoadStrictAndExpectSuccess("update_url_valid_3.json");
-  LoadStrictAndExpectSuccess("update_url_valid_4.json");
+  LoadAndExpectSuccess("update_url_valid_1.json", Extension::INTERNAL,
+                       Extension::STRICT_ERROR_CHECKS);
+  LoadAndExpectSuccess("update_url_valid_2.json", Extension::INTERNAL,
+                       Extension::STRICT_ERROR_CHECKS);
+  LoadAndExpectSuccess("update_url_valid_3.json", Extension::INTERNAL,
+                       Extension::STRICT_ERROR_CHECKS);
+  LoadAndExpectSuccess("update_url_valid_4.json", Extension::INTERNAL,
+                       Extension::STRICT_ERROR_CHECKS);
 
   // Test some invalid update urls
-  LoadAndExpectErrorStrict("update_url_invalid_1.json",
-      errors::kInvalidUpdateURL);
-  LoadAndExpectErrorStrict("update_url_invalid_2.json",
-      errors::kInvalidUpdateURL);
-  LoadAndExpectErrorStrict("update_url_invalid_3.json",
-      errors::kInvalidUpdateURL);
+  LoadAndExpectError("update_url_invalid_1.json", errors::kInvalidUpdateURL,
+                     Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
+  LoadAndExpectError("update_url_invalid_2.json", errors::kInvalidUpdateURL,
+                     Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
+  LoadAndExpectError("update_url_invalid_3.json", errors::kInvalidUpdateURL,
+                     Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
 }
 
 // Tests that the old permission name "unlimited_storage" still works for
 // backwards compatibility (we renamed it to "unlimitedStorage").
 TEST_F(ExtensionManifestTest, OldUnlimitedStoragePermission) {
-  scoped_refptr<Extension> extension = LoadStrictAndExpectSuccess(
-      "old_unlimited_storage.json");
+  scoped_refptr<Extension> extension = LoadAndExpectSuccess(
+      "old_unlimited_storage.json", Extension::INTERNAL,
+      Extension::STRICT_ERROR_CHECKS);
   EXPECT_TRUE(extension->HasAPIPermission(
       ExtensionAPIPermission::kUnlimitedStorage));
 }
 
 TEST_F(ExtensionManifestTest, ValidApp) {
   scoped_refptr<Extension> extension(LoadAndExpectSuccess("valid_app.json"));
   URLPatternSet expected_patterns;
   AddPattern(&expected_patterns, "http://www.google.com/mail/*");
   AddPattern(&expected_patterns, "http://www.google.com/foobar/*");
   EXPECT_EQ(expected_patterns, extension->web_extent());
@@ skipping 36 matching lines @@
   LoadAndExpectError(
       "web_urls_invalid_5.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidWebURL,
           base::IntToString(1),
           errors::kCannotClaimAllHostsInExtent));
 
   // Ports in app.urls only raise an error when loading as a
   // developer would.
   LoadAndExpectSuccess("web_urls_invalid_has_port.json");
-  LoadAndExpectErrorStrict(
+  LoadAndExpectError(
       "web_urls_invalid_has_port.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidWebURL,
           base::IntToString(1),
-          URLPattern::GetParseResultString(URLPattern::PARSE_ERROR_HAS_COLON)));
-
+          URLPattern::GetParseResultString(URLPattern::PARSE_ERROR_HAS_COLON)),
+      Extension::INTERNAL,
+      Extension::STRICT_ERROR_CHECKS);
 
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("web_urls_default.json"));
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
   EXPECT_EQ("*://www.google.com/*",
             extension->web_extent().patterns().begin()->GetAsString());
 }
 
 TEST_F(ExtensionManifestTest, AppLaunchContainer) {
   scoped_refptr<Extension> extension;
@@ skipping 80 matching lines @@
 TEST_F(ExtensionManifestTest, ChromeURLPermissionInvalid) {
   LoadAndExpectError("permission_chrome_url_invalid.json",
       errors::kInvalidPermissionScheme);
 }
 
 TEST_F(ExtensionManifestTest, ChromeResourcesPermissionValidOnlyForComponents) {
   LoadAndExpectError("permission_chrome_resources_url.json",
       errors::kInvalidPermissionScheme);
   std::string error;
   scoped_refptr<Extension> extension;
-  extension = LoadExtensionWithLocation(
+  extension = LoadExtension(
       "permission_chrome_resources_url.json",
+      &error,
       Extension::COMPONENT,
-      true,  // Strict error checking
-      &error);
+      Extension::STRICT_ERROR_CHECKS);
   EXPECT_EQ("", error);
 }
 
 TEST_F(ExtensionManifestTest, InvalidContentScriptMatchPattern) {
 
   // chrome:// urls are not allowed.
   LoadAndExpectError(
       "content_script_chrome_url_invalid.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidMatch,
           base::IntToString(0),
           base::IntToString(0),
           URLPattern::GetParseResultString(
               URLPattern::PARSE_ERROR_INVALID_SCHEME)));
 
   // Match paterns must be strings.
   LoadAndExpectError(
       "content_script_match_pattern_not_string.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidMatch,
           base::IntToString(0),
           base::IntToString(0),
           errors::kExpectString));
 
   // Ports in match patterns cause an error, but only when loading
   // in developer mode.
   LoadAndExpectSuccess("forbid_ports_in_content_scripts.json");
 
   // Loading as a developer would should give an error.
-  LoadAndExpectErrorStrict(
+  LoadAndExpectError(
       "forbid_ports_in_content_scripts.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidMatch,
           base::IntToString(1),
           base::IntToString(0),
           URLPattern::GetParseResultString(
-              URLPattern::PARSE_ERROR_HAS_COLON)));
+              URLPattern::PARSE_ERROR_HAS_COLON)),
+      Extension::INTERNAL,
+      Extension::STRICT_ERROR_CHECKS);
 }
 
 TEST_F(ExtensionManifestTest, ExcludeMatchPatterns) {
   LoadAndExpectSuccess("exclude_matches.json");
   LoadAndExpectSuccess("exclude_matches_empty.json");
 
   LoadAndExpectError("exclude_matches_not_list.json",
                      "Invalid value for 'content_scripts[0].exclude_matches'.");
 
   LoadAndExpectError("exclude_matches_invalid_host.json",
                      "Invalid value for "
                      "'content_scripts[0].exclude_matches[0]': "
                      "Invalid host wildcard.");
 }
 
 TEST_F(ExtensionManifestTest, ExperimentalPermission) {
   LoadAndExpectError("experimental.json", errors::kExperimentalFlagRequired);
+  LoadAndExpectSuccess("experimental.json", Extension::COMPONENT);
+  LoadAndExpectSuccess("experimental.json", Extension::INTERNAL,
+                       Extension::FROM_WEBSTORE);
   CommandLine old_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalExtensionApis);
   LoadAndExpectSuccess("experimental.json");
   *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 TEST_F(ExtensionManifestTest, DevToolsExtensions) {
   LoadAndExpectError("devtools_extension_no_permissions.json",
       errors::kDevToolsExperimental);
@@ skipping 103 matching lines @@
 
     if (*i == ExtensionAPIPermission::kExperimental) {
       // Experimental permission is allowed, but requires this switch.
       CommandLine::ForCurrentProcess()->AppendSwitch(
           switches::kEnableExperimentalExtensionApis);
     }
 
     // Extensions are allowed to contain unrecognized API permissions,
     // so there shouldn't be any errors.
     scoped_refptr<Extension> extension;
-    extension = LoadAndExpectSuccess(manifest.get(), message_name);
+    extension = LoadAndExpectSuccess(
+        Manifest(manifest.get(), message_name.c_str()));
   }
   *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 TEST_F(ExtensionManifestTest, NormalizeIconPaths) {
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("normalize_icon_paths.json"));
   EXPECT_EQ("16.png",
             extension->icons().Get(16, ExtensionIconSet::MATCH_EXACTLY));
   EXPECT_EQ("48.png",
@@ skipping 128 matching lines @@
 }
 
 TEST_F(ExtensionManifestTest, ForbidPortsInPermissions) {
   // Loading as a user would shoud not trigger an error.
   LoadAndExpectSuccess("forbid_ports_in_permissions.json");
 
   // Ideally, loading as a developer would give an error.
   // To ensure that we do not error out on a valid permission
   // in a future version of chrome, validation is to loose
   // to flag this case.
-  LoadStrictAndExpectSuccess("forbid_ports_in_permissions.json");
+  LoadAndExpectSuccess("forbid_ports_in_permissions.json",
+                       Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
 }
 
 TEST_F(ExtensionManifestTest, IsolatedApps) {
   // Requires --enable-experimental-extension-apis
   LoadAndExpectError("isolated_app_valid.json",
                      errors::kExperimentalFlagRequired);
 
   CommandLine old_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalExtensionApis);
@@ skipping 35 matching lines @@
   const URLPatternSet& patterns = action->file_url_patterns();
   ASSERT_EQ(patterns.patterns().size(), 1U);
   ASSERT_TRUE(action->MatchesURL(
       GURL("filesystem:chrome-extension://foo/local/test.txt")));
 }
 
 TEST_F(ExtensionManifestTest, FileManagerURLOverride) {
   // A component extention can override chrome://files/ URL.
   std::string error;
   scoped_refptr<Extension> extension;
-  extension = LoadExtensionWithLocation(
+  extension = LoadExtension(
       "filebrowser_url_override.json",
+      &error,
       Extension::COMPONENT,
-      true,  // Strict error checking
-      &error);
+      Extension::STRICT_ERROR_CHECKS);
 #if defined(FILE_MANAGER_EXTENSION)
   EXPECT_EQ("", error);
 #else
   EXPECT_EQ(errors::kInvalidChromeURLOverrides, error);
 #endif
 
   // Extensions of other types can't ovverride chrome://files/ URL.
   LoadAndExpectError("filebrowser_url_override.json",
       errors::kInvalidChromeURLOverrides);
 }
@@ skipping 10 matching lines @@
   scoped_refptr<Extension> extension_2(
       LoadAndExpectSuccess("offline_disabled_packaged_app.json"));
   EXPECT_FALSE(extension_2->offline_enabled());
   scoped_refptr<Extension> extension_3(
       LoadAndExpectSuccess("offline_default_packaged_app.json"));
   EXPECT_FALSE(extension_3->offline_enabled());
   scoped_refptr<Extension> extension_4(
       LoadAndExpectSuccess("offline_enabled_hosted_app.json"));
   EXPECT_TRUE(extension_4->offline_enabled());
 }