Move StartsWith[ASCII] to base namespace.

net/base/mime_util.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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 265 matching lines @@
     }
   }
 
   // Test length to prevent overlap between |left| and |right|.
   if (base_type.length() < base_pattern.length() - 1)
     return false;
 
   const std::string left(base_pattern.substr(0, star));
   const std::string right(base_pattern.substr(star + 1));
 
-  if (!StartsWithASCII(base_type, left, false))
+  if (!base::StartsWithASCII(base_type, left, false))
     return false;
 
   if (!right.empty() && !EndsWith(base_type, right, false))
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 }
 
 // See http://www.iana.org/assignments/media-types/media-types.xhtml
 static const char* const legal_top_level_types[] = {
@@ skipping 26 matching lines @@
   return true;
 }
 
 bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const {
   std::string lower_type = base::StringToLowerASCII(type_string);
   for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
     if (lower_type.compare(legal_top_level_types[i]) == 0)
       return true;
   }
 
-  return type_string.size() > 2 && StartsWithASCII(type_string, "x-", false);
+  return type_string.size() > 2 &&
+         base::StartsWithASCII(type_string, "x-", false);
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
@@ skipping 106 matching lines @@
   { "video/", kStandardVideoTypes, arraysize(kStandardVideoTypes) },
   { NULL, NULL, 0 }
 };
 
 void GetExtensionsFromHardCodedMappings(
     const MimeInfo* mappings,
     size_t mappings_len,
     const std::string& leading_mime_type,
     base::hash_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < mappings_len; ++i) {
-    if (StartsWithASCII(mappings[i].mime_type, leading_mime_type, false)) {
+    if (base::StartsWithASCII(mappings[i].mime_type, leading_mime_type,
+                              false)) {
       std::vector<string> this_extensions;
       base::SplitString(mappings[i].extensions, ',', &this_extensions);
       for (size_t j = 0; j < this_extensions.size(); ++j) {
 #if defined(OS_WIN)
         base::FilePath::StringType extension(
             base::UTF8ToWide(this_extensions[j]));
 #else
         base::FilePath::StringType extension(this_extensions[j]);
 #endif
         extensions->insert(extension);
@@ skipping 104 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net