Remove legacy StartsWithASCII function.

components/proximity_auth/cryptauth/fake_secure_message_delegate.cc

 // Copyright 2015 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 "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/md5.h"
@@ skipping 58 matching lines @@
             const std::string& payload,
             const std::string& associated_data,
             const std::string& key,
             const securemessage::SigScheme& signature_scheme) {
   std::string signing_key;
 
   if (signature_scheme == securemessage::HMAC_SHA256) {
     signing_key = key;
   } else {
     std::string prefix = kPrivateKeyPrefix;
-    bool is_private_key = base::StartsWithASCII(key, prefix, true);
+    bool is_private_key =
+        base::StartsWith(key, prefix, base::CompareCase::SENSITIVE);
     signing_key = is_private_key ? key.substr(prefix.size()) : prefix + key;
   }
 
   std::string expected_signature = Sign(payload, associated_data, signing_key);
   return signature == expected_signature;
 }
 
 }  // namespace
 
 FakeSecureMessageDelegate::FakeSecureMessageDelegate()
@@ skipping 16 matching lines @@
 }
 
 void FakeSecureMessageDelegate::DeriveKey(const std::string& private_key,
                                           const std::string& public_key,
                                           const DeriveKeyCallback& callback) {
   // To ensure that the same symmetric key is derived for DeriveKey(private1,
   // public2) and DeriveKey(private2, public1), we remove the prefix from the
   // private key so it is equal to its corresponding public key.
   std::string prefix(kPrivateKeyPrefix);
   std::string normalized_private_key =
-      base::StartsWithASCII(private_key, prefix, true)
+      base::StartsWith(private_key, prefix, base::CompareCase::SENSITIVE)
           ? private_key.substr(prefix.size())
           : private_key;
 
   std::vector<std::string> keys;
   keys.push_back(normalized_private_key);
   keys.push_back(public_key);
   std::sort(keys.begin(), keys.end());
   callback.Run(base::MD5String(keys[0] + "|" + keys[1]));
 }
 
@@ skipping 61 matching lines @@
     callback.Run(false, std::string(), securemessage::Header());
   }
 }
 
 std::string FakeSecureMessageDelegate::GetPrivateKeyForPublicKey(
     const std::string& public_key) {
   return kPrivateKeyPrefix + public_key;
 }
 
 }  // namespace proximity_auth