content: Move kStandardSchemeSeparator into content namespace.

chrome/common/extensions/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 "chrome/common/extensions/url_pattern.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 126 matching lines @@
   SetMatchSubdomains(false);
   SetPort("*");
 
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     SetMatchAllURLs(true);
     return PARSE_SUCCESS;
   }
 
   // Parse out the scheme.
-  size_t scheme_end_pos = pattern.find(chrome::kStandardSchemeSeparator);
+  size_t scheme_end_pos = pattern.find(content::kStandardSchemeSeparator);
   bool has_standard_scheme_separator = true;
 
   // Some urls also use ':' alone as the scheme separator.
   if (scheme_end_pos == std::string::npos) {
     scheme_end_pos = pattern.find(':');
     has_standard_scheme_separator = false;
   }
 
   if (scheme_end_pos == std::string::npos)
     return PARSE_ERROR_MISSING_SCHEME_SEPARATOR;
 
   if (!SetScheme(pattern.substr(0, scheme_end_pos)))
     return PARSE_ERROR_INVALID_SCHEME;
 
   bool standard_scheme = IsStandardScheme(scheme_);
   if (standard_scheme != has_standard_scheme_separator)
     return PARSE_ERROR_WRONG_SCHEME_SEPARATOR;
 
   // Advance past the scheme separator.
   scheme_end_pos +=
-      (standard_scheme ? strlen(chrome::kStandardSchemeSeparator) : 1);
+      (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_ == chrome::kFileScheme) {
@@ skipping 154 matching lines @@
 
 bool URLPattern::MatchesScheme(const std::string& test) const {
   if (!IsValidScheme(test))
     return false;
 
   return scheme_ == "*" || test == scheme_;
 }
 
 bool URLPattern::MatchesHost(const std::string& host) const {
   std::string test(chrome::kHttpScheme);
-  test += chrome::kStandardSchemeSeparator;
+  test += content::kStandardSchemeSeparator;
   test += host;
   test += "/";
   return MatchesHost(GURL(test));
 }
 
 bool URLPattern::MatchesHost(const GURL& test) const {
   // If the hosts are exactly equal, we have a match.
   if (test.host() == host_)
     return true;
 
@@ skipping 43 matching lines @@
     return spec_;
 
   if (match_all_urls_) {
     spec_ = kAllUrlsPattern;
     return spec_;
   }
 
   bool standard_scheme = IsStandardScheme(scheme_);
 
   std::string spec = scheme_ +
-      (standard_scheme ? chrome::kStandardSchemeSeparator : ":");
+      (standard_scheme ? content::kStandardSchemeSeparator : ":");
 
   if (scheme_ != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
@@ skipping 94 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }