Add sanbdoxed_pages to allow extension/app pages to be served in a sandboxed, unique origin

chrome/common/extensions/extension.cc

 // Copyright (c) 2012 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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 508 matching lines @@
   return false;
 }
 
 bool Extension::HasWebAccessibleResources() const {
   if (web_accessible_resources_.size())
     return true;
 
   return false;
 }
 
+bool Extension::IsResourceSandboxed(const std::string& relative_path) const {
+  return sandboxed_resources_.find(relative_path) !=
+    sandboxed_resources_.end();
+}
+
 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 734 matching lines @@
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
   if (!LoadDescription(error) ||
       !LoadHomepageURL(error) ||
       !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
       !LoadCommands(error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadWebAccessibleResources(error) ||
+      !LoadSandboxedResources(error) ||
       !CheckRequirements(error) ||
       !LoadDefaultLocale(error) ||
       !LoadOfflineEnabled(error) ||
       !LoadOptionsPage(error) ||
       // LoadBackgroundScripts() must be called before LoadBackgroundPage().
       !LoadBackgroundScripts(error) ||
       !LoadBackgroundPage(api_permissions, error) ||
       !LoadBackgroundPersistent(api_permissions, error) ||
       !LoadBackgroundAllowJSAccess(api_permissions, error) ||
       !LoadWebIntentServices(error))
@@ skipping 271 matching lines @@
       return false;
     }
     if (relative_path[0] != '/')
       relative_path = '/' + relative_path;
     web_accessible_resources_.insert(relative_path);
   }
 
   return true;
 }
 
+bool Extension::LoadSandboxedResources(string16* error) {
+  if (!manifest_->HasKey(keys::kSandboxedResources))
+    return true;
+  ListValue* list_value;

[Aaron Boodman, 2012/06/04 07:05:42]

= NULL;

[Mihai Parparita -not on Chrome, 2012/06/05 04:32:40]

Done (though I don't think it's necessary; we don't look at the value that it's
set to if the return value of GetList indicates an error).

+  if (!manifest_->GetList(keys::kSandboxedResources, &list_value)) {
+    *error = ASCIIToUTF16(errors::kInvalidSandboxedResourcesList);
+    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::kInvalidSandboxedResource, base::IntToString(i));
+      return false;
+    }
+    if (relative_path[0] != '/')
+      relative_path = '/' + relative_path;
+    sandboxed_resources_.insert(relative_path);
+  }
+
+  return true;
+}
+
 // These are not actually persisted (they're only used by the store), but
 // still validated.
 bool Extension::CheckRequirements(string16* error) {
   if (!manifest_->HasKey(keys::kRequirements))
     return true;
   DictionaryValue* requirements_value = NULL;
   if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
     *error = ASCIIToUTF16(errors::kInvalidRequirements);
     return false;
   }
@@ skipping 2050 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions