Move some content url constants to /url.

url/url_util.cc

 // Copyright 2013 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 "url/url_util.h"
 
 #include <string.h>
 #include <vector>
 
 #include "base/logging.h"
 #include "url/url_canon_internal.h"
 #include "url/url_file.h"
 #include "url/url_util_internal.h"
 
 namespace url {
 
-const char kFileScheme[] = "file";
-const char kFileSystemScheme[] = "filesystem";
-const char kMailtoScheme[] = "mailto";
-
 namespace {
 
 // ASCII-specific tolower.  The standard library's tolower is locale sensitive,
 // so we don't want to use it here.
 template<class Char>
 inline Char ToLowerASCII(Char c) {
   return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
 }
 
 // Backend for LowerCaseEqualsASCII.
 template<typename Iter>
 inline bool DoLowerCaseEqualsASCII(Iter a_begin, Iter a_end, const char* b) {
   for (Iter it = a_begin; it != a_end; ++it, ++b) {
     if (!*b || ToLowerASCII(*it) != *b)
       return false;
   }
   return *b == 0;
 }
 
 const int kNumStandardURLSchemes = 8;
 const char* kStandardURLSchemes[kNumStandardURLSchemes] = {
   "http",
   "https",
-  kFileScheme,  // Yes, file urls can have a hostname!
+  url::kFileScheme,  // Yes, file urls can have a hostname!

[blundell, 2014/05/28 11:21:49]

nit: it looks like this code is already in the url namespace.

[Sungmann Cho, 2014/05/28 11:54:59]

Done.

   "ftp",
   "gopher",
   "ws",  // WebSocket.
   "wss",  // WebSocket secure.
-  kFileSystemScheme,
+  url::kFileSystemScheme,
 };
 
 // List of the currently installed standard schemes. This list is lazily
 // initialized by InitStandardSchemes and is leaked on shutdown to prevent
 // any destructors from being called that will slow us down or cause problems.
 std::vector<const char*>* standard_schemes = NULL;
 
 // See the LockStandardSchemes declaration in the header.
 bool standard_schemes_locked = false;
 
@@ skipping 94 matching lines @@
   }
 #endif
 
   Component scheme;
   if (!ExtractScheme(spec, spec_len, &scheme))
     return false;
 
   // This is the parsed version of the input URL, we have to canonicalize it
   // before storing it in our object.
   bool success;
-  if (DoCompareSchemeComponent(spec, scheme, kFileScheme)) {
+  if (DoCompareSchemeComponent(spec, scheme, url::kFileScheme)) {
     // File URLs are special.
     ParseFileURL(spec, spec_len, &parsed_input);
     success = CanonicalizeFileURL(spec, spec_len, parsed_input,
                                   charset_converter, output, output_parsed);
-  } else if (DoCompareSchemeComponent(spec, scheme, kFileSystemScheme)) {
+  } else if (DoCompareSchemeComponent(spec, scheme, url::kFileSystemScheme)) {
     // Filesystem URLs are special.
     ParseFileSystemURL(spec, spec_len, &parsed_input);
     success = CanonicalizeFileSystemURL(spec, spec_len, parsed_input,
                                         charset_converter, output,
                                         output_parsed);
 
   } else if (DoIsStandard(spec, scheme)) {
     // All "normal" URLs.
     ParseStandardURL(spec, spec_len, &parsed_input);
     success = CanonicalizeStandardURL(spec, spec_len, parsed_input,
                                       charset_converter, output, output_parsed);
 
-  } else if (DoCompareSchemeComponent(spec, scheme, kMailtoScheme)) {
+  } else if (DoCompareSchemeComponent(spec, scheme, url::kMailToScheme)) {
     // Mailto are treated like a standard url with only a scheme, path, query
     ParseMailtoURL(spec, spec_len, &parsed_input);
     success = CanonicalizeMailtoURL(spec, spec_len, parsed_input, output,
                                     output_parsed);
 
   } else {
     // "Weird" URLs like data: and javascript:
     ParsePathURL(spec, spec_len, trim_path_end, &parsed_input);
     success = CanonicalizePathURL(spec, spec_len, parsed_input, output,
                                   output_parsed);
@@ skipping 135 matching lines @@
     // ref).
     Replacements<CHAR> replacements_no_scheme = replacements;
     replacements_no_scheme.SetScheme(NULL, Component());
     return DoReplaceComponents(recanonicalized.data(), recanonicalized.length(),
                                recanonicalized_parsed, replacements_no_scheme,
                                charset_converter, output, out_parsed);
   }
 
   // If we get here, then we know the scheme doesn't need to be replaced, so can
   // just key off the scheme in the spec to know how to do the replacements.
-  if (DoCompareSchemeComponent(spec, parsed.scheme, kFileScheme)) {
+  if (DoCompareSchemeComponent(spec, parsed.scheme, url::kFileScheme)) {
     return ReplaceFileURL(spec, parsed, replacements, charset_converter, output,
                           out_parsed);
   }
-  if (DoCompareSchemeComponent(spec, parsed.scheme, kFileSystemScheme)) {
+  if (DoCompareSchemeComponent(spec, parsed.scheme, url::kFileSystemScheme)) {
     return ReplaceFileSystemURL(spec, parsed, replacements, charset_converter,
                                 output, out_parsed);
   }
   if (DoIsStandard(spec, parsed.scheme)) {
     return ReplaceStandardURL(spec, parsed, replacements, charset_converter,
                               output, out_parsed);
   }
-  if (DoCompareSchemeComponent(spec, parsed.scheme, kMailtoScheme)) {
+  if (DoCompareSchemeComponent(spec, parsed.scheme, url::kMailToScheme)) {
     return ReplaceMailtoURL(spec, parsed, replacements, output, out_parsed);
   }
 
   // Default is a path URL.
   return ReplacePathURL(spec, parsed, replacements, output, out_parsed);
 }
 
 }  // namespace
 
 void Initialize() {
@@ skipping 217 matching lines @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 bool CompareSchemeComponent(const base::char16* spec,
                             const Component& component,
                             const char* compare_to) {
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 }  // namespace url