Remove SandboxedPages and SandboxedCSP from Extension Class

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 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_util.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 // TODO(rdevlin.cronin): Remove these once all references have been removed as
 // part of crbug.com/159265.
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/api/extension_action/page_action_handler.h"
 #include "chrome/common/extensions/api/icons/icons_handler.h"
 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
 #include "chrome/common/extensions/api/themes/theme_handler.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/csp_handler.h"
-#include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/permissions/api_permission_set.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
+#include "chrome/common/extensions/sandboxed_page_info.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "grit/generated_resources.h"
 #endif
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 namespace info_keys = extension_info_keys;
 
-using extensions::csp_validator::ContentSecurityPolicyIsLegal;
-using extensions::csp_validator::ContentSecurityPolicyIsSandboxed;
-
 namespace extensions {
 
 namespace {
 
 const int kModernManifestVersion = 2;
 const int kPEMOutputColumns = 65;
 
 // The maximum number of commands (including page action/browser actions) an
 // extension can have.
 const size_t kMaxCommandsPerExtension = 4;
 
 // KEY MARKERS
 const char kKeyBeginHeaderMarker[] = "-----BEGIN";
 const char kKeyBeginFooterMarker[] = "-----END";
 const char kKeyInfoEndMarker[] = "KEY-----";
 const char kPublic[] = "PUBLIC";
 const char kPrivate[] = "PRIVATE";
 
 const int kRSAKeySize = 1024;
 
-const char kDefaultSandboxedPageContentSecurityPolicy[] =
-    "sandbox allow-scripts allow-forms allow-popups";
-
 // Converts a normal hexadecimal string into the alphabet used by extensions.
 // We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
 // completely numeric host, since some software interprets that as an IP
 // address.
 static void ConvertHexadecimalToIDAlphabet(std::string* id) {
   for (size_t i = 0; i < id->size(); ++i) {
     int val;
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
                              &val)) {
@@ skipping 259 matching lines @@
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
 bool Extension::ResourceMatches(const URLPatternSet& pattern_set,
                                 const std::string& resource) const {
   return pattern_set.MatchesURL(extension_url_.Resolve(resource));
 }
 
-bool Extension::IsSandboxedPage(const std::string& relative_path) const {
-  return ResourceMatches(sandboxed_pages_, relative_path);
-}
-
 std::string Extension::GetResourceContentSecurityPolicy(

[Yoyo Zhou, 2013/03/25 17:16:01]

Can this function be moved to CSPInfo? I think it could even make sense to
combine the CSP and sandboxed page manifest handlers, but you don't have to do
that in this CL.

[Devlin, 2013/03/26 23:00:15]

Done.

     const std::string& relative_path) const {
-  return IsSandboxedPage(relative_path) ?
-      sandboxed_pages_content_security_policy_ :
+  return SandboxedPageInfo::IsSandboxedPage(this, relative_path) ?
+      SandboxedPageInfo::GetContentSecurityPolicy(this) :
       CSPInfo::GetContentSecurityPolicy(this);
 }
 
 ExtensionResource Extension::GetResource(
     const std::string& relative_path) const {
   std::string new_path = relative_path;
   // We have some legacy data where resources have leading slashes.
   // See: http://crbug.com/121164
   if (!new_path.empty() && new_path.at(0) == '/')
     new_path.erase(0, 1);
@@ skipping 1350 matching lines @@
     extent_.ClearPatterns();
   }
 
   return true;
 }
 
 bool Extension::LoadSharedFeatures(string16* error) {
   if (!LoadDescription(error) ||
       !ManifestHandler::ParseExtension(this, error) ||
       !LoadNaClModules(error) ||
-      !LoadSandboxedPages(error) ||
       !LoadRequirements(error) ||
       !LoadKioskEnabled(error) ||
       !LoadOfflineEnabled(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadDescription(string16* error) {
   if (manifest_->HasKey(keys::kDescription) &&
@@ skipping 63 matching lines @@
     }
 
     nacl_modules_.push_back(NaClModuleInfo());
     nacl_modules_.back().url = GetResourceURL(path_str);
     nacl_modules_.back().mime_type = mime_type;
   }
 
   return true;
 }
 
-bool Extension::LoadSandboxedPages(string16* error) {
-  if (!manifest_->HasPath(keys::kSandboxedPages))
-    return true;
-
-  const ListValue* list_value = NULL;
-  if (!manifest_->GetList(keys::kSandboxedPages, &list_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesList);
-    return false;
-  }
-  for (size_t i = 0; i < list_value->GetSize(); ++i) {
-    std::string relative_path;
-    if (!list_value->GetString(i, &relative_path)) {
-      *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidSandboxedPage, base::IntToString(i));
-      return false;
-    }
-    URLPattern pattern(URLPattern::SCHEME_EXTENSION);
-    if (pattern.Parse(extension_url_.spec()) != URLPattern::PARSE_SUCCESS) {
-      *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidURLPatternError, extension_url_.spec());
-      return false;
-    }
-    while (relative_path[0] == '/')
-      relative_path = relative_path.substr(1, relative_path.length() - 1);
-    pattern.SetPath(pattern.path() + relative_path);
-    sandboxed_pages_.AddPattern(pattern);
-  }
-
-  if (manifest_->HasPath(keys::kSandboxedPagesCSP)) {
-    if (!manifest_->GetString(
-        keys::kSandboxedPagesCSP, &sandboxed_pages_content_security_policy_)) {
-      *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
-      return false;
-    }
-
-    if (!ContentSecurityPolicyIsLegal(
-            sandboxed_pages_content_security_policy_) ||
-        !ContentSecurityPolicyIsSandboxed(
-            sandboxed_pages_content_security_policy_, GetType())) {
-      *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
-      return false;
-    }
-  } else {
-    sandboxed_pages_content_security_policy_ =
-        kDefaultSandboxedPageContentSecurityPolicy;
-    CHECK(ContentSecurityPolicyIsSandboxed(
-        sandboxed_pages_content_security_policy_, GetType()));
-  }
-
-  return true;
-}
-
 bool Extension::LoadRequirements(string16* error) {
   // Before parsing requirements from the manifest, automatically default the
   // NPAPI plugin requirement based on whether it includes NPAPI plugins.
   const ListValue* list_value = NULL;
   requirements_.npapi =
     manifest_->GetList(keys::kPlugins, &list_value) && !list_value->empty();
 
   if (!manifest_->HasKey(keys::kRequirements))
     return true;
 
@@ skipping 615 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions