Add 'web_accessible_resource" keyword for version 2 extension manifests. This makes extension res...

chrome/common/extensions/extension.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"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 354 matching lines @@
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK_EQ("/", extension_url.path());
 
   GURL ret_val = GURL(extension_url.spec() + relative_path);
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
+bool Extension::IsResourceWebAccessible(const std::string& relative_path)
+    const {
+  // For old manifest versions which do not specify web_accessible_resources
+  // we always allow resource loads.
+  if (manifest_version() < 2 && !HasWebAccessibleResources())
+    return true;
+
+  if (web_accessible_resources_.find(relative_path) !=
+      web_accessible_resources_.end())
+    return true;
+
+  return false;
+}
+
+bool Extension::HasWebAccessibleResources() const {
+  if (web_accessible_resources_.size())
+    return true;
+
+  return false;
+}
+
 bool Extension::GenerateId(const std::string& input, std::string* output) {
   DCHECK(output);
   uint8 hash[Extension::kIdSize];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   *output = StringToLowerASCII(base::HexEncode(hash, sizeof(hash)));
   ConvertHexadecimalToIDAlphabet(output);
 
   return true;
 }
 
@@ skipping 1436 matching lines @@
         return false;  // Failed to parse script context definition.
       script.set_extension_id(id());
       if (converted_from_user_script_) {
         script.set_emulate_greasemonkey(true);
         script.set_match_all_frames(true);  // Greasemonkey matches all frames.
       }
       content_scripts_.push_back(script);
     }
   }
 
+  // Initialize web accessible resources (optional).
+  if (manifest->HasKey(keys::kWebAccessibleResources)) {
+    ListValue* list_value;
+    if (!manifest->GetList(keys::kWebAccessibleResources, &list_value)) {
+      *error = ASCIIToUTF16(errors::kInvalidWebAccessibleResourcesList);
+      return false;
+    }
+    for (size_t i = 0; i < list_value->GetSize(); ++i) {
+      std::string relative_path;
+      if (!list_value->GetString(i, &relative_path)) {
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidWebAccessibleResource, base::IntToString(i));
+        return false;
+      }
+      if (relative_path[0] != '/')
+        relative_path = '/' + relative_path;
+      web_accessible_resources_.insert(relative_path);
+    }
+  }
+
   // Initialize page action (optional).
   DictionaryValue* page_action_value = NULL;
 
   if (manifest->HasKey(keys::kPageActions)) {
     ListValue* list_value = NULL;
     if (!manifest->GetList(keys::kPageActions, &list_value)) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionsList);
       return false;
     }
 
@@ skipping 1139 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}