Track permissions granted to extensions in prefs

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 2010 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 @@
 
 void CompareLists(const std::vector<std::string>& expected,
                   const std::vector<std::string>& actual) {
   ASSERT_EQ(expected.size(), actual.size());
 
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i], actual[i]);
   }
 }
 
+static void AddPattern(ExtensionExtent* extent, const std::string& pattern) {
+  int schemes = URLPattern::SCHEME_ALL;
+  extent->AddPattern(URLPattern(schemes, pattern));
+}
+
 }
 
 class ExtensionTest : public testing::Test {
 };
 
 // We persist location values in the preferences, so this is a sanity test that
 // someone doesn't accidentally change them.
 TEST(ExtensionTest, LocationValuesTest) {
   ASSERT_EQ(0, Extension::INVALID);
   ASSERT_EQ(1, Extension::INTERNAL);
@@ skipping 184 matching lines @@
   input_value->Set(keys::kPermissions, Value::CreateIntegerValue(9));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermissions));
 
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
   input_value->GetList(keys::kPermissions, &permissions);
   permissions->Set(0, Value::CreateIntegerValue(24));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &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_FALSE(extension.InitFromValue(*input_value, true, &error));
-  EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermission));
+  EXPECT_TRUE(extension.InitFromValue(*input_value, true, &error));
 
   // Multiple page actions are not allowed.
   input_value.reset(static_cast<DictionaryValue*>(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);
@@ skipping 52 matching lines @@
   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);
-  EXPECT_FALSE(extension.InitFromValue(input_value, false, &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.
+  EXPECT_TRUE(extension.InitFromValue(input_value, false, &error));
   input_value.Remove(keys::kPermissions, NULL);
-  error.clear();
 
   // Test with an options page.
   input_value.SetString(keys::kOptionsPage, "options.html");
   EXPECT_TRUE(extension.InitFromValue(input_value, false, &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.
@@ skipping 465 matching lines @@
   hosts = extension->GetEffectiveHostPermissions();
   EXPECT_FALSE(hosts.ContainsURL(GURL("http://test/")));
   EXPECT_TRUE(hosts.ContainsURL(GURL("https://test/")));
   EXPECT_TRUE(hosts.ContainsURL(GURL("http://www.google.com")));
   EXPECT_TRUE(extension->HasEffectiveAccessToAllHosts());
 }
 
 TEST(ExtensionTest, IsPrivilegeIncrease) {
   const struct {
     const char* base_name;
+    const char** granted_apis;
+    const char** granted_hosts;
     bool expect_success;
   } kTests[] = {
-    { "allhosts1", false },  // all -> all
-    { "allhosts2", false },  // all -> one
-    { "allhosts3", true },  // one -> all
-    { "hosts1", false },  // http://a,http://b -> http://a,http://b
-    { "hosts2", false },  // http://a,http://b -> https://a,http://*.b
-    { "hosts3", false },  // http://a,http://b -> http://a
-    { "hosts4", true },  // http://a -> http://a,http://b
-    { "hosts5", false },  // http://a,b,c -> http://a,b,c + https://a,b,c
-    { "hosts6", false },  // http://a.com -> http://a.com + http://a.co.uk
-    { "permissions1", false },  // tabs -> tabs
-    { "permissions2", true },  // tabs -> tabs,bookmarks
-    { "permissions3", true },  // http://a -> http://a,tabs
-    { "permissions5", true },  // bookmarks -> bookmarks,history
+    { "allhosts1", (const char*[]){NULL},
+      (const char*[]){"http://*/", NULL},
+      false },  // all -> all
+    { "allhosts2", (const char*[]){NULL},
+      (const char*[]){"http://*/", NULL},
+      false },  // all -> one
+    { "allhosts3", (const char*[]){NULL},
+      (const char*[]){NULL}, true },  // one -> all
+    { "hosts1", (const char*[]){NULL},
+      (const char*[]){"http://www.google.com/", "http://www.reddit.com/", NULL},
+      false },  // http://a,http://b -> http://a,http://b
+    { "hosts2", (const char*[]){NULL},
+      (const char*[]){"http://www.google.com/", "http://www.reddit.com/", NULL},
+      false },  // http://a,http://b -> https://a,http://*.b
+    { "hosts3", (const char*[]){NULL},
+      (const char*[]){"http://www.google.com/", "http://www.reddit.com/", NULL},
+      false },  // http://a,http://b -> http://a
+    { "hosts4", (const char*[]){NULL},
+      (const char*[]){"http://www.google.com/", NULL},
+      true },  // http://a -> http://a,http://b
+    { "hosts5", (const char*[]){"tabs", "notifications", NULL},
+      (const char*[]){"http://*.example.com/", "http://*.example.com/*",
+                      "http://*.example.co.uk/*", "http://*.example.com.au/*",
+                      NULL},
+      false },  // http://a,b,c -> http://a,b,c + https://a,b,c
+    { "hosts6", (const char*[]){"tabs", "notifications", NULL},
+      (const char*[]){"http://*.example.com/", "http://*.example.com/*", NULL},
+      false },  // http://a.com -> http://a.com + http://a.co.uk
+    { "permissions1", (const char*[]){"tabs", NULL},
+      (const char*[]){NULL}, false },  // tabs -> tabs
+    { "permissions2", (const char*[]){"tabs", NULL},
+      (const char*[]){NULL}, true },  // tabs -> tabs,bookmarks
+    { "permissions3", (const char*[]){NULL},
+      (const char*[]){"http://*/*", NULL},
+      true },  // http://a -> http://a,tabs
+    { "permissions5", (const char*[]){"bookmarks", NULL},
+      (const char*[]){NULL}, true },  // bookmarks -> bookmarks,history
 #if !defined(OS_CHROMEOS)  // plugins aren't allowed in ChromeOS
-    { "permissions4", false },  // plugin -> plugin,tabs
-    { "plugin1", false },  // plugin -> plugin
-    { "plugin2", false },  // plugin -> none
-    { "plugin3", true },  // none -> plugin
+    { "permissions4", (const char*[]){NULL},
+      (const char*[]){NULL}, false },  // plugin -> plugin,tabs
+    { "plugin1", (const char*[]){NULL},
+      (const char*[]){NULL}, false },  // plugin -> plugin
+    { "plugin2", (const char*[]){NULL},
+      (const char*[]){NULL}, false },  // plugin -> none
+    { "plugin3", (const char*[]){NULL},
+      (const char*[]){NULL}, true },  // none -> plugin
 #endif
-    { "storage", false },  // none -> storage
-    { "notifications", false }  // none -> notifications
+    { "storage", (const char*[]){NULL},
+      (const char*[]){NULL}, false },  // none -> storage
+    { "notifications", (const char*[]){NULL},
+      (const char*[]){NULL}, false }  // none -> notifications
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     scoped_refptr<Extension> old_extension(
         LoadManifest("allow_silent_upgrade",
                      std::string(kTests[i].base_name) + "_old.json"));
     scoped_refptr<Extension> new_extension(
         LoadManifest("allow_silent_upgrade",
                      std::string(kTests[i].base_name) + "_new.json"));
 
+    std::set<std::string> granted_apis;
+    for (size_t j = 0; kTests[i].granted_apis[j] != NULL; ++j)
+      granted_apis.insert(kTests[i].granted_apis[j]);
+
+    ExtensionExtent granted_hosts;
+    for (size_t j = 0; kTests[i].granted_hosts[j] != NULL; ++j)
+      AddPattern(&granted_hosts, kTests[i].granted_hosts[j]);
+
     EXPECT_TRUE(old_extension.get()) << kTests[i].base_name << "_old.json";
     EXPECT_TRUE(new_extension.get()) << kTests[i].base_name << "_new.json";
     if (!old_extension.get() || !new_extension.get())
       continue;
 
     EXPECT_EQ(kTests[i].expect_success,
-              Extension::IsPrivilegeIncrease(old_extension.get(),
+              Extension::IsPrivilegeIncrease(granted_apis, granted_hosts,
+                                             old_extension.get(),
                                              new_extension.get()))
         << kTests[i].base_name;
   }
 }
 
 TEST(ExtensionTest, PermissionMessages) {
   // Ensure that all permissions that needs to show install UI actually have
   // strings associated with them.
 
   std::set<std::string> skip;
@@ skipping 291 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");
 }