Clean content_settings_pattern_parser.* from unnecessary dependencies.

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 "components/content_settings/core/common/embedder_variables.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
-#include "url/url_canon.h"
 
 namespace {
 
 std::string GetDefaultPort(const std::string& scheme) {
   if (scheme == url::kHttpScheme)
     return "80";
   if (scheme == url::kHttpsScheme)
     return "443";
   return std::string();
 }
@@ skipping 47 matching lines @@
   return 0;
 }
 
 typedef ContentSettingsPattern::BuilderInterface BuilderInterface;
 
 }  // namespace
 
 // ////////////////////////////////////////////////////////////////////////////
 // ContentSettingsPattern::Builder
 //
+class ContentSettingsPattern::Builder :
+    public ContentSettingsPattern::BuilderInterface {
+ public:
+  explicit Builder(bool use_legacy_validate);
+  virtual ~Builder();
+
+  // BuilderInterface:
+  virtual BuilderInterface* WithPort(const std::string& port) OVERRIDE;
+  virtual BuilderInterface* WithPortWildcard() OVERRIDE;
+  virtual BuilderInterface* WithHost(const std::string& host) OVERRIDE;
+  virtual BuilderInterface* WithDomainWildcard() OVERRIDE;
+  virtual BuilderInterface* WithScheme(const std::string& scheme) OVERRIDE;
+  virtual BuilderInterface* WithSchemeWildcard() OVERRIDE;
+  virtual BuilderInterface* WithPath(const std::string& path) OVERRIDE;
+  virtual BuilderInterface* WithPathWildcard() OVERRIDE;
+  virtual BuilderInterface* Invalid() OVERRIDE;
+  virtual ContentSettingsPattern Build() OVERRIDE;
+
+ private:
+  // Canonicalizes the pattern parts so that they are ASCII only, either
+  // in original (if it was already ASCII) or punycode form. Returns true if
+  // the canonicalization was successful.
+  static bool Canonicalize(PatternParts* parts);
+
+  // Returns true when the pattern |parts| represent a valid pattern.
+  static bool Validate(const PatternParts& parts);
+
+  static bool LegacyValidate(const PatternParts& parts);
+
+  bool is_valid_;
+
+  bool use_legacy_validate_;
+
+  PatternParts parts_;
+
+  DISALLOW_COPY_AND_ASSIGN(Builder);
+};
+
 ContentSettingsPattern::Builder::Builder(bool use_legacy_validate)
     : is_valid_(true),
       use_legacy_validate_(use_legacy_validate) {}
 
 ContentSettingsPattern::Builder::~Builder() {}
 
 BuilderInterface* ContentSettingsPattern::Builder::WithPort(
     const std::string& port) {
   parts_.port = port;
   parts_.is_port_wildcard = false;
@@ skipping 119 matching lines @@
     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.
-  if (parts.scheme == std::string(extensions::kExtensionScheme) &&
+  if (content_settings::IsNonPortScheme(parts.scheme) &&
       parts.port.empty() &&
       !parts.is_port_wildcard) {
     return true;
   }
 
   // Non-file patterns are invalid if either the scheme, host or port part is
   // empty.
   if ((parts.scheme.empty() && !parts.is_scheme_wildcard) ||
       (parts.host.empty() && !parts.has_domain_wildcard) ||
       (parts.port.empty() && !parts.is_port_wildcard)) {
@@ skipping 16 matching lines @@
 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(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) &&
+  if (content_settings::IsNonPortScheme(parts.scheme) &&
       !parts.is_scheme_wildcard &&
       !parts.host.empty() &&
       !parts.has_domain_wildcard &&
       parts.port.empty() &&
       !parts.is_port_wildcard)
     return true;
 
   // Non-file patterns are invalid if either the scheme, host or port part is
   // empty.
   if ((!parts.is_scheme_wildcard) ||
@@ skipping 29 matching lines @@
 // following patterns:
 //   - [*.]domain.tld (matches domain.tld and all sub-domains)
 //   - host (matches an exact hostname)
 //   - a.b.c.d (matches an exact IPv4 ip)
 //   - [a:b:c:d:e:f:g:h] (matches an exact IPv6 ip)
 //   - file:///tmp/test.html (a complete URL without a host)
 // Version 2 adds a resource identifier for plugins.
 // TODO(jochen): update once this feature is no longer behind a flag.
 const int ContentSettingsPattern::kContentSettingsPatternVersion = 1;
 
-// TODO(markusheintz): These two constants were moved to the Pattern Parser.
-// Remove once the dependency of the ContentSettingsBaseProvider is removed.
-const char* ContentSettingsPattern::kDomainWildcard = "[*.]";
-const size_t ContentSettingsPattern::kDomainWildcardLength = 4;
-
 // static
 BuilderInterface* ContentSettingsPattern::CreateBuilder(
     bool validate) {
   return new Builder(validate);
 }
 
 // static
 ContentSettingsPattern ContentSettingsPattern::FromURL(
     const GURL& url) {
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
@@ skipping 52 matching lines @@
     }
   }
   return builder->Build();
 }
 
 // static
 ContentSettingsPattern ContentSettingsPattern::FromString(
     const std::string& pattern_spec) {
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(false));
-  content_settings::PatternParser::Parse(pattern_spec, builder.get());
+  content_settings::PatternParser::Parse(pattern_spec,
+                                         builder.get());
   return builder->Build();
 }
 
-// static
-ContentSettingsPattern ContentSettingsPattern::LegacyFromString(
-    const std::string& pattern_spec) {
-  scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
-      ContentSettingsPattern::CreateBuilder(true));
-  content_settings::PatternParser::Parse(pattern_spec, builder.get());
-  return builder->Build();
-}
-
 // static
 ContentSettingsPattern ContentSettingsPattern::Wildcard() {
   scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(true));
   builder->WithSchemeWildcard()->WithDomainWildcard()->WithPortWildcard()->
            WithPathWildcard();
   return builder->Build();
 }
 
 ContentSettingsPattern::ContentSettingsPattern()
   : is_valid_(false) {
 }
 
 ContentSettingsPattern::ContentSettingsPattern(
     const PatternParts& parts,
     bool valid)
     : parts_(parts),
       is_valid_(valid) {
 }
 
-void ContentSettingsPattern::WriteToMessage(IPC::Message* m) const {
-  IPC::WriteParam(m, is_valid_);
-  IPC::WriteParam(m, parts_);
-}
-
-bool ContentSettingsPattern::ReadFromMessage(const IPC::Message* m,
-                                             PickleIterator* iter) {
-  return IPC::ReadParam(m, iter, &is_valid_) &&
-         IPC::ReadParam(m, iter, &parts_);
-}
-
 bool ContentSettingsPattern::Matches(
     const GURL& url) const {
   // An invalid pattern matches nothing.
   if (!is_valid_)
     return false;
 
   const GURL* local_url = &url;
   if (url.SchemeIsFileSystem() && url.inner_url()) {
     local_url = url.inner_url();
   }
@@ skipping 20 matching lines @@
   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))
       return false;
   }
 
   // For chrome extensions URLs ignore the port.
-  if (parts_.scheme == std::string(extensions::kExtensionScheme))
+  if (content_settings::IsNonPortScheme(parts_.scheme))
     return true;
 
   // Match the port part.
   std::string port(local_url->port());
 
   // Use the default port if the port string is empty. GURL returns an empty
   // string if no port at all was specified or if the default port was
   // specified.
   if (port.empty()) {
     port = GetDefaultPort(scheme);
   }
 
   if (!parts_.is_port_wildcard &&
       parts_.port != port ) {
     return false;
   }
 
   return true;
 }
 
 bool ContentSettingsPattern::MatchesAllHosts() const {
   return parts_.has_domain_wildcard && parts_.host.empty();
 }
 
-const std::string ContentSettingsPattern::ToString() const {
+std::string ContentSettingsPattern::ToString() const {
   if (IsValid())
     return content_settings::PatternParser::ToString(parts_);
   else
     return std::string();
 }
 
 ContentSettingsPattern::Relation ContentSettingsPattern::Compare(
     const ContentSettingsPattern& other) const {
   // Two invalid patterns are identical in the way they behave. They don't match
   // anything and are represented as an empty string. So it's fair to treat them
@@ skipping 163 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;
 }