Make <all_urls> and file:///* in permissions trigger "Allow file access"

chrome/common/extensions/extension_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 759 matching lines @@
   data.clear();
   result.clear();
   path = path.DirName().AppendASCII("bad_magic.crx");
   ASSERT_TRUE(file_util::ReadFileToString(path, &data));
   EXPECT_TRUE(net::SniffMimeType(data.c_str(), data.size(),
               GURL("http://www.example.com/foo.crx"), "", &result));
   EXPECT_EQ("application/octet-stream", result);
 }
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
-                                             const std::string& test_file) {
+                                             const std::string& test_file,
+                                             int extra_flags) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.AppendASCII("extensions")
              .AppendASCII(dir)
              .AppendASCII(test_file);
 
   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()),
-      Extension::STRICT_ERROR_CHECKS, &error);
+      Extension::STRICT_ERROR_CHECKS | extra_flags, &error);
   EXPECT_TRUE(extension) << error;
   return extension;
 }
 
+static scoped_refptr<Extension> LoadManifest(const std::string& dir,
+                                             const std::string& test_file) {
+  return LoadManifest(dir, test_file, Extension::NO_FLAGS);
+}
+
 TEST(ExtensionTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
   ExtensionExtent hosts;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
   EXPECT_EQ(0u, extension->GetEffectiveHostPermissions().patterns().size());
   EXPECT_FALSE(hosts.ContainsURL(GURL("http://www.google.com")));
   EXPECT_FALSE(extension->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "one_host.json");
@@ skipping 345 matching lines @@
 
 TEST(ExtensionTest, GetHostPermissionMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings = extension->GetPermissionMessages();
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Your data on www.google.com and encrypted.google.com",
             UTF16ToUTF8(warnings[0]));
 }
 
+TEST(ExtensionTest, WantsFileAccess) {
+  scoped_refptr<Extension> extension;
+  GURL file_url("file:///etc/passwd");
+
+  // <all_urls> permission
+  extension = LoadManifest("permissions", "permissions_all_urls.json");
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+  extension = LoadManifest(
+      "permissions", "permissions_all_urls.json", Extension::ALLOW_FILE_ACCESS);
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_TRUE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+
+  // file:///* permission
+  extension = LoadManifest("permissions", "permissions_file_scheme.json");
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+  extension = LoadManifest("permissions", "permissions_file_scheme.json",
+      Extension::ALLOW_FILE_ACCESS);
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_TRUE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+
+  // http://* permission
+  extension = LoadManifest("permissions", "permissions_http_scheme.json");
+  EXPECT_FALSE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+  extension = LoadManifest("permissions", "permissions_http_scheme.json",
+      Extension::ALLOW_FILE_ACCESS);
+  EXPECT_FALSE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(file_url, NULL, NULL));
+
+  // <all_urls> content script match
+  extension = LoadManifest("permissions", "content_script_all_urls.json");
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+  extension = LoadManifest("permissions", "content_script_all_urls.json",
+      Extension::ALLOW_FILE_ACCESS);
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_TRUE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+
+  // file:///* content script match
+  extension = LoadManifest("permissions", "content_script_file_scheme.json");
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+  extension = LoadManifest("permissions", "content_script_file_scheme.json",
+      Extension::ALLOW_FILE_ACCESS);
+  EXPECT_TRUE(extension->wants_file_access());
+  EXPECT_TRUE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+
+  // http://* content script match
+  extension = LoadManifest("permissions", "content_script_http_scheme.json");
+  EXPECT_FALSE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+  extension = LoadManifest("permissions", "content_script_http_scheme.json",
+      Extension::ALLOW_FILE_ACCESS);
+  EXPECT_FALSE(extension->wants_file_access());
+  EXPECT_FALSE(extension->CanExecuteScriptOnPage(
+      file_url, &extension->content_scripts()[0], NULL));
+}
+
 TEST(ExtensionTest, GetDistinctHostsForDisplay) {
   std::vector<std::string> expected;
   expected.push_back("www.foo.com");
   expected.push_back("www.bar.com");
   expected.push_back("www.baz.com");
   URLPatternList actual;
 
   {
     SCOPED_TRACE("no dupes");
 
@@ skipping 245 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");
 }