Move some content url constants to /url.

extensions/common/url_pattern.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 "extensions/common/url_pattern.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "url/gurl.h"
 #include "url/url_util.h"
 
 const char URLPattern::kAllUrlsPattern[] = "<all_urls>";
 
 namespace {
 
 // TODO(aa): What about more obscure schemes like data: and javascript: ?
 // Note: keep this array in sync with kValidSchemeMasks.
 const char* kValidSchemes[] = {
     url::kHttpScheme,
     url::kHttpsScheme,
-    content::kFileScheme,
-    content::kFtpScheme,
+    url::kFileScheme,
+    url::kFtpScheme,
     content::kChromeUIScheme,
     extensions::kExtensionScheme,
-    content::kFileSystemScheme,
+    url::kFileSystemScheme,
 };
 
 const int kValidSchemeMasks[] = {
   URLPattern::SCHEME_HTTP,
   URLPattern::SCHEME_HTTPS,
   URLPattern::SCHEME_FILE,
   URLPattern::SCHEME_FTP,
   URLPattern::SCHEME_CHROMEUI,
   URLPattern::SCHEME_EXTENSION,
   URLPattern::SCHEME_FILESYSTEM,
@@ skipping 145 matching lines @@
       (standard_scheme ? strlen(content::kStandardSchemeSeparator) : 1);
   if (scheme_end_pos >= pattern.size())
     return PARSE_ERROR_EMPTY_HOST;
 
   // Parse out the host and path.
   size_t host_start_pos = scheme_end_pos;
   size_t path_start_pos = 0;
 
   if (!standard_scheme) {
     path_start_pos = host_start_pos;
-  } else if (scheme_ == content::kFileScheme) {
+  } else if (scheme_ == url::kFileScheme) {
     size_t host_end_pos = pattern.find(kPathSeparator, host_start_pos);
     if (host_end_pos == std::string::npos) {
       // Allow hostname omission.
       // e.g. file://* is interpreted as file:///*,
       // file://foo* is interpreted as file:///foo*.
       path_start_pos = host_start_pos - 1;
     } else {
       // Ignore hostname if scheme is file://.
       // e.g. file://localhost/foo is equal to file:///foo.
       path_start_pos = host_end_pos;
@@ skipping 213 matching lines @@
   if (match_all_urls_) {
     spec_ = kAllUrlsPattern;
     return spec_;
   }
 
   bool standard_scheme = IsStandardScheme(scheme_);
 
   std::string spec = scheme_ +
       (standard_scheme ? content::kStandardSchemeSeparator : ":");
 
-  if (scheme_ != content::kFileScheme && standard_scheme) {
+  if (scheme_ != url::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
 
     if (port_ != "*") {
@@ skipping 46 matching lines @@
        i != schemes.end(); ++i) {
     if (!MatchesScheme(*i))
       return false;
   }
 
   return true;
 }
 
 bool URLPattern::MatchesSecurityOriginHelper(const GURL& test) const {
   // Ignore hostname if scheme is file://.
-  if (scheme_ != content::kFileScheme && !MatchesHost(test))
+  if (scheme_ != url::kFileScheme && !MatchesHost(test))
     return false;
 
   if (!MatchesPortPattern(base::IntToString(test.EffectiveIntPort())))
     return false;
 
   return true;
 }
 
 bool URLPattern::MatchesPortPattern(const std::string& port) const {
   return port_ == "*" || port_ == port;
@@ skipping 29 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }