Move StringToUpperASCII and LowerCaseEqualsASCII to the base namespace

net/filter/filter.cc

 // Copyright 2014 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 "net/filter/filter.h"
 
 #include "base/files/file_path.h"
 #include "base/strings/string_util.h"
 #include "net/base/filename_util_unsafe.h"
 #include "net/base/io_buffer.h"
@@ skipping 120 matching lines @@
 
   next_stream_data_ = stream_buffer()->data();
   stream_data_len_ = stream_data_len;
   return true;
 }
 
 // static
 Filter::FilterType Filter::ConvertEncodingToType(
     const std::string& filter_type) {
   FilterType type_id;
-  if (LowerCaseEqualsASCII(filter_type, kDeflate)) {
+  if (base::LowerCaseEqualsASCII(filter_type, kDeflate)) {
     type_id = FILTER_TYPE_DEFLATE;
-  } else if (LowerCaseEqualsASCII(filter_type, kGZip) ||
-             LowerCaseEqualsASCII(filter_type, kXGZip)) {
+  } else if (base::LowerCaseEqualsASCII(filter_type, kGZip) ||
+             base::LowerCaseEqualsASCII(filter_type, kXGZip)) {
     type_id = FILTER_TYPE_GZIP;
-  } else if (LowerCaseEqualsASCII(filter_type, kSdch)) {
+  } else if (base::LowerCaseEqualsASCII(filter_type, kSdch)) {
     type_id = FILTER_TYPE_SDCH;
   } else {
     // Note we also consider "identity" and "uncompressed" UNSUPPORTED as
     // filter should be disabled in such cases.
     type_id = FILTER_TYPE_UNSUPPORTED;
   }
   return type_id;
 }
 
 // static
 void Filter::FixupEncodingTypes(
     const FilterContext& filter_context,
     std::vector<FilterType>* encoding_types) {
   std::string mime_type;
   bool success = filter_context.GetMimeType(&mime_type);
   DCHECK(success || mime_type.empty());
 
   if ((1 == encoding_types->size()) &&
       (FILTER_TYPE_GZIP == encoding_types->front())) {
-    if (LowerCaseEqualsASCII(mime_type, kApplicationXGzip) ||
-        LowerCaseEqualsASCII(mime_type, kApplicationGzip) ||
-        LowerCaseEqualsASCII(mime_type, kApplicationXGunzip))
+    if (base::LowerCaseEqualsASCII(mime_type, kApplicationXGzip) ||
+        base::LowerCaseEqualsASCII(mime_type, kApplicationGzip) ||
+        base::LowerCaseEqualsASCII(mime_type, kApplicationXGunzip))
       // The server has told us that it sent us gziped content with a gzip
       // content encoding.  Sadly, Apache mistakenly sets these headers for all
       // .gz files.  We match Firefox's nsHttpChannel::ProcessNormal and ignore
       // the Content-Encoding here.
       encoding_types->clear();
 
     GURL url;
     std::string disposition;
     success = filter_context.GetURL(&url);
     DCHECK(success);
     filter_context.GetContentDisposition(&disposition);
     // Don't supply a MIME type here, since that may cause disk IO.
     base::FilePath::StringType extension =
         GenerateFileExtensionUnsafe(url, disposition, "UTF-8", "", "", "");
 
     if (filter_context.IsDownload()) {
       // We don't want to decompress gzipped files when the user explicitly
       // asks to download them.
       // For the case of svgz files, we use the extension to distinguish
       // between svgz files and svg files compressed with gzip by the server.
       // When viewing a .svgz file, we need to uncompress it, but we don't
       // want to do that when downloading.
       // See Firefox's nonDecodableExtensions in nsExternalHelperAppService.cpp
       if (EndsWith(extension, FILE_PATH_LITERAL(".gz"), false) ||
-          LowerCaseEqualsASCII(extension, ".tgz") ||
-          LowerCaseEqualsASCII(extension, ".svgz"))
+          base::LowerCaseEqualsASCII(extension, ".tgz") ||
+          base::LowerCaseEqualsASCII(extension, ".svgz"))
         encoding_types->clear();
     } else {
       // When the user does not explicitly ask to download a file, if we get a
       // supported mime type, then we attempt to decompress in order to view it.
       // However, if it's not a supported mime type, then we will attempt to
       // download it, and in that case, don't decompress .gz/.tgz files.
       if ((EndsWith(extension, FILE_PATH_LITERAL(".gz"), false) ||
-           LowerCaseEqualsASCII(extension, ".tgz")) &&
+           base::LowerCaseEqualsASCII(extension, ".tgz")) &&
           !IsSupportedMimeType(mime_type))
         encoding_types->clear();
     }
   }
 
   // If the request was for SDCH content, then we might need additional fixups.
   if (!filter_context.IsSdchResponse()) {
     // It was not an SDCH request, so we'll just record stats.
     if (1 < encoding_types->size()) {
       // Multiple filters were intended to only be used for SDCH (thus far!)
@@ skipping 187 matching lines @@
 
 void Filter::PushDataIntoNextFilter() {
   IOBuffer* next_buffer = next_filter_->stream_buffer();
   int next_size = next_filter_->stream_buffer_size();
   last_status_ = ReadFilteredData(next_buffer->data(), &next_size);
   if (FILTER_ERROR != last_status_)
     next_filter_->FlushStreamBuffer(next_size);
 }
 
 }  // namespace net