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"
 #include "base/strings/string_util.h"
 #include "chrome/common/content_settings_pattern_parser.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "ipc/ipc_message_utils.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_util.h"
+#include "net/base/url_constants.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 
 namespace {
 
 std::string GetDefaultPort(const std::string& scheme) {
-  if (scheme == content::kHttpScheme)
+  if (scheme == net::kHttpScheme)
     return "80";
-  if (scheme == content::kHttpsScheme)
+  if (scheme == net::kHttpsScheme)
     return "443";
   return std::string();
 }
 
 // Returns true if |sub_domain| is a sub domain or equls |domain|.  E.g.
 // "mail.google.com" is a sub domain of "google.com" but "evilhost.com" is not a
 // subdomain of "host.com".
 bool IsSubDomainOrEqual(const std::string& sub_domain,
                         const std::string& domain) {
   // The empty string serves as wildcard. Each domain is a subdomain of the
@@ skipping 198 matching lines @@
       (parts.host.empty() && !parts.has_domain_wildcard) ||
       (parts.port.empty() && !parts.is_port_wildcard)) {
     return false;
   }
 
   if (parts.host.find("*") != std::string::npos)
     return false;
 
   // Test if the scheme is supported or a wildcard.
   if (!parts.is_scheme_wildcard &&
-      parts.scheme != std::string(content::kHttpScheme) &&
-      parts.scheme != std::string(content::kHttpsScheme)) {
+      parts.scheme != std::string(net::kHttpScheme) &&
+      parts.scheme != std::string(net::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) &&
@@ skipping 13 matching lines @@
 
   // Non-file patterns are invalid if either the scheme, host or port part is
   // empty.
   if ((!parts.is_scheme_wildcard) ||
       (parts.host.empty() && !parts.has_domain_wildcard) ||
       (!parts.is_port_wildcard))
     return false;
 
   // Test if the scheme is supported or a wildcard.
   if (!parts.is_scheme_wildcard &&
-      parts.scheme != std::string(content::kHttpScheme) &&
-      parts.scheme != std::string(content::kHttpsScheme)) {
+      parts.scheme != std::string(net::kHttpScheme) &&
+      parts.scheme != std::string(net::kHttpsScheme)) {
     return false;
   }
   return true;
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // ContentSettingsPattern::PatternParts
 //
 ContentSettingsPattern::PatternParts::PatternParts()
         : is_scheme_wildcard(false),
@@ skipping 39 matching lines @@
   if (url.SchemeIsFileSystem() && url.inner_url()) {
     local_url = url.inner_url();
   }
   if (local_url->SchemeIsFile()) {
     builder->WithScheme(local_url->scheme())->WithPath(local_url->path());
   } else {
     // Please keep the order of the ifs below as URLs with an IP as host can
     // also have a "http" scheme.
     if (local_url->HostIsIPAddress()) {
       builder->WithScheme(local_url->scheme())->WithHost(local_url->host());
-    } else if (local_url->SchemeIs(content::kHttpScheme)) {
+    } else if (local_url->SchemeIs(net::kHttpScheme)) {
       builder->WithSchemeWildcard()->WithDomainWildcard()->WithHost(
           local_url->host());
-    } else if (local_url->SchemeIs(content::kHttpsScheme)) {
+    } else if (local_url->SchemeIs(net::kHttpsScheme)) {
       builder->WithScheme(local_url->scheme())->WithDomainWildcard()->WithHost(
           local_url->host());
     } else {
       // Unsupported scheme
     }
     if (local_url->port().empty()) {
-      if (local_url->SchemeIs(content::kHttpsScheme))
-        builder->WithPort(GetDefaultPort(content::kHttpsScheme));
+      if (local_url->SchemeIs(net::kHttpsScheme))
+        builder->WithPort(GetDefaultPort(net::kHttpsScheme));
       else
         builder->WithPortWildcard();
     } else {
       builder->WithPort(local_url->port());
     }
   }
   return builder->Build();
 }
 
 // static
@@ skipping 310 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;
 }