Clean content_settings_pattern_parser.* from unnecessary dependencies.

chrome/common/content_settings_pattern_parser.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_parser.h"
 
 #include "base/strings/string_util.h"
-#include "chrome/common/url_constants.h"
-#include "extensions/common/constants.h"
-#include "net/base/net_util.h"
-#include "url/gurl.h"
-#include "url/url_canon.h"
+#include "components/content_settings/core/common/embedder_variables.h"
+#include "url/url_constants.h"
 
 namespace {
 
-const char* kUrlPathSeparator = "/";
-const char* kUrlPortSeparator = ":";
+const char kDomainWildcard[] = "[*.]";
+const size_t kDomainWildcardLength = 4;
+const char kHostWildcard[] = "*";
+const char kPathWildcard[] = "*";
+const char kPortWildcard[] = "*";
+const char kSchemeWildcard[] = "*";
+const char kUrlPathSeparator[] = "/";
+const char kUrlPortSeparator[] = ":";
 
 class Component {
  public:
   Component() : start(0), len(0) {}
   Component(size_t s, size_t l) : start(s), len(l) {}
 
   bool IsNonEmpty() {
     return len > 0;
   }
 
   size_t start;
   size_t len;
 };
 
 }  // namespace
 
 namespace content_settings {
 
-const char* PatternParser::kDomainWildcard = "[*.]";
-
-const size_t PatternParser::kDomainWildcardLength = 4;
-
-const char* PatternParser::kSchemeWildcard = "*";
-
-const char* PatternParser::kHostWildcard = "*";
-
-const char* PatternParser::kPortWildcard = "*";
-
-const char* PatternParser::kPathWildcard = "*";
-
-// static
 void PatternParser::Parse(const std::string& pattern_spec,
                           ContentSettingsPattern::BuilderInterface* builder) {
   if (pattern_spec == "*") {
     builder->WithSchemeWildcard();
     builder->WithDomainWildcard();
     builder->WithPortWildcard();
     return;
   }
 
   // Initialize components for the individual patterns parts to empty
   // sub-strings.
   Component scheme_component;
   Component host_component;
   Component port_component;
   Component path_component;
 
   size_t start = 0;
   size_t current_pos = 0;
 
   if (pattern_spec.empty())
     return;
 
   // Test if a scheme pattern is in the spec.
-  current_pos = pattern_spec.find(
-      std::string(url::kStandardSchemeSeparator), start);
+  const std::string standard_scheme_separator(url::kStandardSchemeSeparator);
+  current_pos = pattern_spec.find(standard_scheme_separator, start);
   if (current_pos != std::string::npos) {
     scheme_component = Component(start, current_pos);
-    start = current_pos + strlen(url::kStandardSchemeSeparator);
+    start = current_pos + standard_scheme_separator.size();
     current_pos = start;
   } else {
     current_pos = start;
   }
 
   if (start >= pattern_spec.size())
     return;  // Bad pattern spec.
 
   // Jump to the end of domain wildcards or an IPv6 addresses. IPv6 addresses
   // contain ':'. So first move to the end of an IPv6 address befor searching
@@ skipping 78 matching lines @@
       for (size_t i = 0; i < port.size(); ++i) {
         if (!IsAsciiDigit(port[i])) {
           builder->Invalid();
           return;
         }
       }
       // TODO(markusheintz): Check port range.
       builder->WithPort(port);
     }
   } else {
-    if (scheme != std::string(extensions::kExtensionScheme) &&
-        scheme != std::string(url::kFileScheme))
+    if (!content_settings::IsNonPortScheme(scheme) &&
+        scheme != url::kFileScheme)
       builder->WithPortWildcard();
   }
 
   if (path_component.IsNonEmpty()) {
     const std::string path = pattern_spec.substr(path_component.start,
                                                  path_component.len);
     if (path.substr(1) == kPathWildcard)
       builder->WithPathWildcard();
     else
       builder->WithPath(path);
   }
 }
 
-// static

[vabr (Chromium), 2014/08/20 09:52:22]

The header still declares this method as static. Please put the header and the
cc file back in sync on that.

[vasilii, 2014/08/21 14:58:02]

Done.

 std::string PatternParser::ToString(
     const ContentSettingsPattern::PatternParts& parts) {
   // Return the most compact form to support legacy code and legacy pattern
   // strings.
   if (parts.is_scheme_wildcard &&
       parts.has_domain_wildcard &&
       parts.host.empty() &&
       parts.is_port_wildcard)
     return "*";
 
   std::string str;
   if (!parts.is_scheme_wildcard)
     str += parts.scheme + url::kStandardSchemeSeparator;
 
   if (parts.scheme == url::kFileScheme) {
     if (parts.is_path_wildcard)
       return str + kUrlPathSeparator + kPathWildcard;
     else
       return str + parts.path;
   }
 
   if (parts.has_domain_wildcard) {
     if (parts.host.empty())
       str += kHostWildcard;
     else
       str += kDomainWildcard;
   }
   str += parts.host;
 
-  if (parts.scheme == std::string(extensions::kExtensionScheme)) {
+  if (content_settings::IsNonPortScheme(parts.scheme)) {

[vabr (Chromium), 2014/08/20 09:52:22]

I believe this path should work for file: as well. Could you confirm, possibly
with Markus?

[vasilii, 2014/08/21 14:58:02]

It's handled above. The file path can be wildcard. Also for empty extension path
we add '/'.

[vabr (Chromium), 2014/08/21 15:31:41]

Ah, I see. Special casing the file URL here makes sense. On other places, a
file: URL is treated the same as the extension scheme URLs, and in those cases,
having IsNonWildcardDomainNonPortScheme match also file: would make sense. If we
go that way, we should comment here on line 195, that the special-case of file:
needs to come before the case of IsNonWildcardDomainNonPortScheme.

However, this is only an optional comment. I don't want to diverge too much from
the original goal of the CL -- removing dependencies. Even the current state is
acceptable for me.

[vasilii, 2014/08/22 13:02:45]

I don't know if there are other places where the difference matters. There is a
risk that I'll be reverting it back again.

     str += parts.path.empty() ? std::string(kUrlPathSeparator) : parts.path;
     return str;
   }
 
   if (!parts.is_port_wildcard) {
     str += std::string(kUrlPortSeparator) + parts.port;
   }
 
   return str;
 }
 
 }  // namespace content_settings