Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

chrome/common/extensions/csp_validator.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/csp_validator.h"
 
 #include "base/string_split.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 
@@ skipping 17 matching lines @@
     : directive_name(name)
     , seen_in_policy(false)
     , is_secure(false) {
   }
 
   const char* directive_name;
   bool seen_in_policy;
   bool is_secure;
 };
 
-bool HasOnlySecureTokens(StringTokenizer& tokenizer, Extension::Type type) {
+bool HasOnlySecureTokens(StringTokenizer& tokenizer, Manifest::Type type) {
   while (tokenizer.GetNext()) {
     std::string source = tokenizer.token();
     StringToLowerASCII(&source);
 
     // Don't alow whitelisting of all hosts. This boils down to:
     //   1. Maximum of 2 '*' characters.
     //   2. Each '*' is either followed by a '.' or preceded by a ':'
     int wildcards = 0;
     size_t length = source.length();
     for (size_t i = 0; i < length; ++i) {
@@ skipping 19 matching lines @@
         StartsWithASCII(source, "http://127.0.0.1:", false) ||
         StartsWithASCII(source, "http://localhost:", false) ||
         StartsWithASCII(source, "https://", true) ||
         StartsWithASCII(source, "chrome://", true) ||
         StartsWithASCII(source, "chrome-extension://", true) ||
         StartsWithASCII(source, "chrome-extension-resource:", true)) {
       continue;
     }
 
     // crbug.com/146487
-    if (type == Extension::TYPE_EXTENSION ||
-        type == Extension::TYPE_LEGACY_PACKAGED_APP) {
+    if (type == Manifest::TYPE_EXTENSION ||
+        type == Manifest::TYPE_LEGACY_PACKAGED_APP) {
       if (source == "'unsafe-eval'")
         continue;
     }
 
     return false;
   }
 
   return true;  // Empty values default to 'none', which is secure.
 }
 
 // Returns true if |directive_name| matches |status.directive_name|.
 bool UpdateStatus(const std::string& directive_name,
                   StringTokenizer& tokenizer,
                   DirectiveStatus* status,
-                  Extension::Type type) {
+                  Manifest::Type type) {
   if (status->seen_in_policy)
     return false;
   if (directive_name != status->directive_name)
     return false;
   status->seen_in_policy = true;
   status->is_secure = HasOnlySecureTokens(tokenizer, type);
   return true;
 }
 
 }  //  namespace
 
 bool ContentSecurityPolicyIsLegal(const std::string& policy) {
   // We block these characters to prevent HTTP header injection when
   // representing the content security policy as an HTTP header.
   const char kBadChars[] = {',', '\r', '\n', '\0'};
 
   return policy.find_first_of(kBadChars, 0, arraysize(kBadChars)) ==
       std::string::npos;
 }
 
 bool ContentSecurityPolicyIsSecure(const std::string& policy,
-                                   Extension::Type type) {
+                                   Manifest::Type type) {
   // See http://www.w3.org/TR/CSP/#parse-a-csp-policy for parsing algorithm.
   std::vector<std::string> directives;
   base::SplitString(policy, ';', &directives);
 
   DirectiveStatus default_src_status(kDefaultSrc);
   DirectiveStatus script_src_status(kScriptSrc);
   DirectiveStatus object_src_status(kObjectSrc);
 
   for (size_t i = 0; i < directives.size(); ++i) {
     std::string& input = directives[i];
@@ skipping 21 matching lines @@
   if (default_src_status.seen_in_policy && !default_src_status.is_secure) {
     return script_src_status.seen_in_policy &&
            object_src_status.seen_in_policy;
   }
 
   return default_src_status.seen_in_policy ||
       (script_src_status.seen_in_policy && object_src_status.seen_in_policy);
 }
 
 bool ContentSecurityPolicyIsSandboxed(
-    const std::string& policy, Extension::Type type) {
+    const std::string& policy, Manifest::Type type) {
   // See http://www.w3.org/TR/CSP/#parse-a-csp-policy for parsing algorithm.
   std::vector<std::string> directives;
   base::SplitString(policy, ';', &directives);
 
   bool seen_sandbox = false;
 
   for (size_t i = 0; i < directives.size(); ++i) {
     std::string& input = directives[i];
     StringTokenizer tokenizer(input, " \t\r\n");
     if (!tokenizer.GetNext())
       continue;
 
     std::string directive_name = tokenizer.token();
     StringToLowerASCII(&directive_name);
 
     if (directive_name != kSandboxDirectiveName)
       continue;
 
     seen_sandbox = true;
 
     while (tokenizer.GetNext()) {
       std::string token = tokenizer.token();
       StringToLowerASCII(&token);
 
       // The same origin token negates the sandboxing.
       if (token == kAllowSameOriginToken)
         return false;
 
       // Platform apps don't allow navigation.
-      if (type == Extension::TYPE_PLATFORM_APP) {
+      if (type == Manifest::TYPE_PLATFORM_APP) {
         if (token == kAllowTopNavigation)
           return false;
       }
     }
   }
 
   return seen_sandbox;
 }
 
 }  // csp_validator
 
 }  // extensions