Track permissions granted to extensions in prefs

chrome/common/extensions/extension_manifests_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 "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
@@ skipping 290 matching lines @@
   ASSERT_TRUE(manifest.get());
 
   ListValue *permissions = new ListValue();
   manifest->Set(keys::kPermissions, permissions);
   for (size_t i = 0; i < Extension::kNumPermissions; i++) {
     const char* name = Extension::kPermissions[i].name;
     StringValue* p = new StringValue(name);
     permissions->Clear();
     permissions->Append(p);
     std::string message_name = base::StringPrintf("permission-%s", name);
-    if (Extension::IsHostedAppPermission(name)) {
-      scoped_refptr<Extension> extension;
-      extension = LoadAndExpectSuccess(manifest.get(), message_name);
-    } else {
-      LoadAndExpectError(manifest.get(), message_name,
-                         errors::kInvalidPermission);
-    }
+
+    // Since we no longer throw errors when permissions aren't recognized,
+    // the extension should successfully load for any of these.

[Aaron Boodman, 2010/11/12 00:05:24]

This comment seems kinda cryptic. How about renaming the test so that it's like
"AllowUnrecognizedPermissions" or something?

Also, do we have a test that handles the case of invalid URLPatterns in host
permissions?

[jstritar, 2010/11/19 21:38:36]

I renamed the test and updated the comment.

As for testing invalid URLPatterns, ChromeURLPermissionInvalid checks for an
error when using the "chrome://newtab/" permission and
ChromeURLContentScriptInvalid tests a similar case for the content_script
matches field. I don't think we can test beyond valid schemes, since we assume
they're unrecognized API permissions when they fail parsing. We could probably
improve error handling by validating the API permissions, by for instance,
assuming it's a URLPattern if it contains one of these chars ".:/". I don't do
this right now though.

+    scoped_refptr<Extension> extension;
+    extension = LoadAndExpectSuccess(manifest.get(), message_name);
   }
 }
 
 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",
             extension->icons().Get(48, ExtensionIconSet::MATCH_EXACTLY));
@@ skipping 32 matching lines @@
 
 TEST_F(ExtensionManifestTest, DefaultPathForExtent) {
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("default_path_for_extent.json"));
 
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
   EXPECT_EQ("/*", extension->web_extent().patterns()[0].path());
   EXPECT_TRUE(extension->web_extent().ContainsURL(
       GURL("http://www.google.com/monkey")));
 }