Move some content url constants to /url.

chrome/common/content_settings_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/content_settings_pattern.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
@@ skipping 161 matching lines @@
 
   return ContentSettingsPattern(parts_, is_valid_);
 }
 
 // static
 bool ContentSettingsPattern::Builder::Canonicalize(PatternParts* parts) {
   // Canonicalize the scheme part.
   const std::string scheme(StringToLowerASCII(parts->scheme));
   parts->scheme = scheme;
 
-  if (parts->scheme == std::string(content::kFileScheme) &&
+  if (parts->scheme == std::string(url::kFileScheme) &&
       !parts->is_path_wildcard) {
-      GURL url(std::string(content::kFileScheme) +
-               std::string(content::kStandardSchemeSeparator) + parts->path);
-      parts->path = url.path();
+    GURL url(std::string(url::kFileScheme) +
+             std::string(content::kStandardSchemeSeparator) + parts->path);
+    parts->path = url.path();
   }
 
   // Canonicalize the host part.
   const std::string host(parts->host);
   url::CanonHostInfo host_info;
   std::string canonicalized_host(net::CanonicalizeHost(host, &host_info));
   if (host_info.IsIPAddress() && parts->has_domain_wildcard)
     return false;
   canonicalized_host = net::TrimEndingDot(canonicalized_host);
 
   parts->host = "";
   if ((host.find('*') == std::string::npos) &&
       !canonicalized_host.empty()) {
     // Valid host.
     parts->host += canonicalized_host;
   }
   return true;
 }
 
 // static
 bool ContentSettingsPattern::Builder::Validate(const PatternParts& parts) {
   // Sanity checks first: {scheme, port} wildcards imply empty {scheme, port}.
   if ((parts.is_scheme_wildcard && !parts.scheme.empty()) ||
       (parts.is_port_wildcard && !parts.port.empty())) {
     NOTREACHED();
     return false;
   }
 
   // file:// URL patterns have an empty host and port.
-  if (parts.scheme == std::string(content::kFileScheme)) {
+  if (parts.scheme == std::string(url::kFileScheme)) {
     if (parts.has_domain_wildcard || !parts.host.empty() || !parts.port.empty())
       return false;
     if (parts.is_path_wildcard)
       return parts.path.empty();
     return (!parts.path.empty() &&
             parts.path != "/" &&
             parts.path.find("*") == std::string::npos);
   }
 
   // If the pattern is for an extension URL test if it is valid.
@@ skipping 20 matching lines @@
       parts.scheme != std::string(url::kHttpsScheme)) {
     return false;
   }
   return true;
 }
 
 // static
 bool ContentSettingsPattern::Builder::LegacyValidate(
     const PatternParts& parts) {
   // If the pattern is for a "file-pattern" test if it is valid.
-  if (parts.scheme == std::string(content::kFileScheme) &&
+  if (parts.scheme == std::string(url::kFileScheme) &&
       !parts.is_scheme_wildcard &&
       parts.host.empty() &&
       parts.port.empty())
     return true;
 
   // If the pattern is for an extension URL test if it is valid.
   if (parts.scheme == std::string(extensions::kExtensionScheme) &&
       !parts.is_scheme_wildcard &&
       !parts.host.empty() &&
       !parts.has_domain_wildcard &&
@@ skipping 182 matching lines @@
     return false;
   }
 
   // File URLs have no host. Matches if the pattern has the path wildcard set,
   // or if the path in the URL is identical to the one in the pattern.
   // For filesystem:file URLs, the path used is the filesystem type, so all
   // filesystem:file:///temporary/... are equivalent.
   // TODO(markusheintz): Content settings should be defined for all files on
   // a machine. Unless there is a good use case for supporting paths for file
   // patterns, stop supporting path for file patterns.
-  if (!parts_.is_scheme_wildcard && scheme == content::kFileScheme)
+  if (!parts_.is_scheme_wildcard && scheme == url::kFileScheme)
     return parts_.is_path_wildcard ||
         parts_.path == std::string(local_url->path());
 
   // Match the host part.
   const std::string host(net::TrimEndingDot(local_url->host()));
   if (!parts_.has_domain_wildcard) {
     if (parts_.host != host)
       return false;
   } else {
     if (!IsSubDomainOrEqual(host, parts_.host))
@@ skipping 203 matching lines @@
   if (!parts.is_port_wildcard && other_parts.is_port_wildcard)
     return ContentSettingsPattern::PREDECESSOR;
 
   int result = parts.port.compare(other_parts.port);
   if (result == 0)
     return ContentSettingsPattern::IDENTITY;
   if (result > 0)
     return ContentSettingsPattern::DISJOINT_ORDER_PRE;
   return ContentSettingsPattern::DISJOINT_ORDER_POST;
 }