Remove legacy StartsWithASCII function.

rlz/lib/rlz_lib.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.
 //
 // A library to manage RLZ information for access-points shared
 // across different client applications.
 
 #include "rlz/lib/rlz_lib.h"
 
 #include "base/strings/string_util.h"
@@ skipping 404 matching lines @@
   int calculated_crc;
   int checksum_index = response_string.find(checksum_param);
   if (checksum_index >= 0) {
     // Calculate checksum of message preceeding checksum line.
     // (+ 1 to include the \n)
     std::string message(response_string.substr(0, checksum_index + 1));
     if (!Crc32(message.c_str(), &calculated_crc))
       return false;
   } else {
     checksum_param = "crc32: ";  // Empty response case.
-    if (!base::StartsWithASCII(response_string, checksum_param, true))
+    if (!base::StartsWith(response_string, checksum_param,
+                          base::CompareCase::SENSITIVE))
       return false;
 
     checksum_index = 0;
     if (!Crc32("", &calculated_crc))
       return false;
   }
 
   // Find the checksum value on the response.
   int checksum_end = response_string.find("\n", checksum_index + 1);
   if (checksum_end < 0)
@@ skipping 91 matching lines @@
     int line_end = line_end_index;
     if (line_end < 0)
       line_end = response_length;
 
     if (line_end <= line_begin)
       continue;  // Empty line.
 
     std::string response_line;
     response_line = response_string.substr(line_begin, line_end - line_begin);
 
-    if (base::StartsWithASCII(response_line, kRlzCgiVariable,
-                              true)) {  // An RLZ.
+    if (base::StartsWith(response_line, kRlzCgiVariable,
+                         base::CompareCase::SENSITIVE)) {  // An RLZ.
       int separator_index = -1;
       if ((separator_index = response_line.find(": ")) < 0)
         continue;  // Not a valid key-value pair.
 
       // Get the access point.
       std::string point_name =
         response_line.substr(3, separator_index - rlz_cgi_length);
       AccessPoint point = NO_ACCESS_POINT;
       if (!GetAccessPointFromName(point_name.c_str(), &point) ||
           point == NO_ACCESS_POINT)
         continue;  // Not a valid access point.
 
       // Get the new RLZ.
       std::string rlz_value(response_line.substr(separator_index + 2));
       base::TrimWhitespaceASCII(rlz_value, base::TRIM_LEADING, &rlz_value);
 
       size_t rlz_length = rlz_value.find_first_of("\r\n ");
       if (rlz_length == std::string::npos)
         rlz_length = rlz_value.size();
 
       if (rlz_length > kMaxRlzLength)
         continue;  // Too long.
 
       if (IsAccessPointSupported(point))
         SetAccessPointRlz(point, rlz_value.substr(0, rlz_length).c_str());
-    } else if (base::StartsWithASCII(response_line, events_variable, true)) {
+    } else if (base::StartsWith(response_line, events_variable,
+                                base::CompareCase::SENSITIVE)) {
       // Clear events which server parsed.
       std::vector<ReturnedEvent> event_array;
       GetEventsFromResponseString(response_line, events_variable, &event_array);
       for (size_t i = 0; i < event_array.size(); ++i) {
         ClearProductEvent(product, event_array[i].access_point,
                           event_array[i].event_type);
       }
-    } else if (base::StartsWithASCII(response_line, stateful_events_variable,
-                                     true)) {
+    } else if (base::StartsWith(response_line, stateful_events_variable,
+                                base::CompareCase::SENSITIVE)) {
       // Record any stateful events the server send over.
       std::vector<ReturnedEvent> event_array;
       GetEventsFromResponseString(response_line, stateful_events_variable,
                                   &event_array);
       for (size_t i = 0; i < event_array.size(); ++i) {
         RecordStatefulEvent(product, event_array[i].access_point,
                             event_array[i].event_type);
       }
     }
   } while (line_end_index >= 0);
@@ skipping 60 matching lines @@
   if (cgi_string.size() >= cgi_size)
     return false;
 
   strncpy(cgi, cgi_string.c_str(), cgi_size);
   cgi[cgi_size - 1] = 0;
 
   return true;
 }
 
 }  // namespace rlz_lib