Remove legacy StartsWithASCII function.

pdf/document_loader.cc

 // Copyright (c) 2010 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 "pdf/document_loader.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 11 matching lines @@
 // If the headers have a byte-range response, writes the start and end
 // positions and returns true if at least the start position was parsed.
 // The end position will be set to 0 if it was not found or parsed from the
 // response.
 // Returns false if not even a start position could be parsed.
 bool GetByteRange(const std::string& headers, uint32_t* start, uint32_t* end) {
   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
   while (it.GetNext()) {
     if (base::LowerCaseEqualsASCII(it.name(), "content-range")) {
       std::string range = it.values().c_str();
-      if (base::StartsWithASCII(range, "bytes", false)) {
+      if (base::StartsWith(range, "bytes",
+                           base::CompareCase::INSENSITIVE_ASCII)) {
         range = range.substr(strlen("bytes"));
         std::string::size_type pos = range.find('-');
         std::string range_end;
         if (pos != std::string::npos)
           range_end = range.substr(pos + 1);
         TrimWhitespaceASCII(range, base::TRIM_LEADING, &range);
         TrimWhitespaceASCII(range_end, base::TRIM_LEADING, &range_end);
         *start = atoi(range.c_str());
         *end = atoi(range_end.c_str());
         return true;
       }
     }
   }
   return false;
 }
 
 // If the headers have a multi-part response, returns the boundary name.
 // Otherwise returns an empty string.
 std::string GetMultiPartBoundary(const std::string& headers) {
   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
   while (it.GetNext()) {
     if (base::LowerCaseEqualsASCII(it.name(), "content-type")) {
       std::string type = base::StringToLowerASCII(it.values());
-      if (base::StartsWithASCII(type, "multipart/", true)) {
+      if (base::StartsWith(type, "multipart/", base::CompareCase::SENSITIVE)) {
         const char* boundary = strstr(type.c_str(), "boundary=");
         if (!boundary) {
           NOTREACHED();
           break;
         }
 
         return std::string(boundary + 9);
       }
     }
   }
@@ skipping 47 matching lines @@
   }
 
   bool accept_ranges_bytes = false;
   bool content_encoded = false;
   uint32_t content_length = 0;
   std::string type;
   std::string disposition;
 
   // This happens for PDFs not loaded from http(s) sources.
   if (response_headers == "Content-Type: text/plain") {
-    if (!base::StartsWithASCII(url, "http://", false) &&
-        !base::StartsWithASCII(url, "https://", false)) {
+    if (!base::StartsWith(url, "http://",
+                          base::CompareCase::INSENSITIVE_ASCII) &&
+        !base::StartsWith(url, "https://",
+                          base::CompareCase::INSENSITIVE_ASCII)) {
       type = "application/pdf";
     }
   }
   if (type.empty() && !response_headers.empty()) {
     net::HttpUtil::HeadersIterator it(response_headers.begin(),
                                       response_headers.end(), "\n");
     while (it.GetNext()) {
       if (base::LowerCaseEqualsASCII(it.name(), "content-length")) {
         content_length = atoi(it.values().c_str());
       } else if (base::LowerCaseEqualsASCII(it.name(), "accept-ranges")) {
         accept_ranges_bytes = base::LowerCaseEqualsASCII(it.values(), "bytes");
       } else if (base::LowerCaseEqualsASCII(it.name(), "content-encoding")) {
         content_encoded = true;
       } else if (base::LowerCaseEqualsASCII(it.name(), "content-type")) {
         type = it.values();
         size_t semi_colon_pos = type.find(';');
         if (semi_colon_pos != std::string::npos) {
           type = type.substr(0, semi_colon_pos);
         }
         TrimWhitespace(type, base::TRIM_ALL, &type);
       } else if (base::LowerCaseEqualsASCII(it.name(), "content-disposition")) {
         disposition = it.values();
       }
     }
   }
   if (!type.empty() && !IsValidContentType(type))
     return false;
-  if (base::StartsWithASCII(disposition, "attachment", false))
+  if (base::StartsWith(disposition, "attachment",
+                       base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
   if (content_length > 0)
     chunk_stream_.Preallocate(content_length);
 
   document_size_ = content_length;
   requests_count_ = 0;
 
   // Enable partial loading only if file size is above the threshold.
   // It will allow avoiding latency for multiple requests.
@@ skipping 365 matching lines @@
 uint32_t DocumentLoader::GetRequestSize() const {
   // Document loading strategy:
   // For first 10 requests, we use 32k chunk sizes, for the next 10 requests we
   // double the size (64k), and so on, until we cap max request size at 2M for
   // 71 or more requests.
   uint32_t limited_count = std::min(std::max(requests_count_, 10u), 70u);
   return 32 * 1024 * (1 << ((limited_count - 1) / 10u));
 }
 
 }  // namespace chrome_pdf