Coalesce more hardcoded schemes to using predefined constants.

chrome/common/extensions/url_pattern.cc

 // Copyright (c) 2006-2009 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_piece.h"
 #include "base/string_util.h"
-#include "chrome/common/extensions/url_pattern.h"
+#include "chrome/common/url_constants.h"
 
 // TODO(aa): Consider adding chrome-extension? What about more obscure ones
 // like data: and javascript: ?
 static const char* kValidSchemes[] = {
-  "http",
-  "https",
-  "file",
-  "ftp",
-  "chrome-ui"
+  chrome::kHttpScheme,
+  chrome::kHttpsScheme,
+  chrome::kFileScheme,
+  chrome::kFtpScheme,
+  chrome::kChromeUIScheme,
 };
 
-static const char kSchemeSeparator[] = "://";
 static const char kPathSeparator[] = "/";
 
 static bool IsValidScheme(const std::string& scheme) {
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (scheme == kValidSchemes[i])
       return true;
   }
 
   return false;
 }
 
 bool URLPattern::Parse(const std::string& pattern) {
-  size_t scheme_end_pos = pattern.find(kSchemeSeparator);
+  size_t scheme_end_pos = pattern.find(chrome::kStandardSchemeSeparator);
   if (scheme_end_pos == std::string::npos)
     return false;
 
   scheme_ = pattern.substr(0, scheme_end_pos);
   if (!IsValidScheme(scheme_))
     return false;
 
-  size_t host_start_pos = scheme_end_pos + strlen(kSchemeSeparator);
+  size_t host_start_pos = scheme_end_pos +
+      strlen(chrome::kStandardSchemeSeparator);
   if (host_start_pos >= pattern.length())
     return false;
 
   // Parse out the host and path.
   size_t path_start_pos = 0;
 
   // File URLs are special because they have no host. There are other schemes
   // with the same structure, but we don't support them (yet).
   if (scheme_ == "file") {
     path_start_pos = host_start_pos;
@@ skipping 70 matching lines @@
     ReplaceSubstringsAfterOffset(&path_escaped_, 0, "?", "\\?");
   }
 
   if (!MatchPattern(test.PathForRequest(), path_escaped_))
     return false;
 
   return true;
 }
 
 std::string URLPattern::GetAsString() const {
-  std::string spec = scheme_ + kSchemeSeparator;
+  std::string spec = scheme_ + chrome::kStandardSchemeSeparator;
 
   if (match_subdomains_) {
     spec += "*";
     if (!host_.empty())
       spec += ".";
   }
 
   if (!host_.empty())
     spec += host_;
 
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }