Update StartsWith calls to use new versions in chrome and content

 true -> base::CompareCase::SENSITIVE
 false with punctuation only -> base::CompareCase::SENSITIVE
 false with ascii constants -> base::CompareCase::INSENSITIVE_ASCII
 false with arbitrary string16 -> base::CompareCase::SENSITIVE with base::i18n::ToLower() on the arguments.

BUG=506920, 506255

Review URL: https://codereview.chromium.org/1214183008

Cr-Commit-Position: refs/heads/master@{#337439}

107 files changed, 418 insertions, 271 deletions

diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index a25e2ba..cb078a0 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -2444,7 +2444,7 @@ void ReportCustomFlags(const std::string& uma_histogram_hame,
                        const std::set<std::string>& command_line_difference) {
   for (const std::string& flag : command_line_difference) {
     int uma_id = about_flags::testing::kBadSwitchFormatHistogramId;
-    if (base::StartsWithASCII(flag, "--", true /* case_sensitive */)) {
+    if (base::StartsWith(flag, "--", base::CompareCase::SENSITIVE)) {
       // Skip '--' before switch name.
       std::string switch_name(flag.substr(2));
 
diff --git a/chrome/browser/android/preferences/website_preference_bridge.cc b/chrome/browser/android/preferences/website_preference_bridge.cc
index b426036..ef40baf 100644
--- a/chrome/browser/android/preferences/website_preference_bridge.cc
+++ b/chrome/browser/android/preferences/website_preference_bridge.cc
@@ -75,12 +75,16 @@ static void GetOrigins(JNIEnv* env,
     const char* kHttpPortSuffix = ":80";
     const char* kHttpsPortSuffix = ":443";
     ScopedJavaLocalRef<jstring> jorigin;
-    if (base::StartsWithASCII(origin, url::kHttpsScheme, false) &&
-        base::EndsWith(origin, kHttpsPortSuffix, false)) {
+    if (base::StartsWith(origin, url::kHttpsScheme,
+                         base::CompareCase::INSENSITIVE_ASCII) &&
+        base::EndsWith(origin, kHttpsPortSuffix,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
       jorigin = ConvertUTF8ToJavaString(
           env, origin.substr(0, origin.size() - strlen(kHttpsPortSuffix)));
-    } else if (base::StartsWithASCII(origin, url::kHttpScheme, false) &&
-               base::EndsWith(origin, kHttpPortSuffix, false)) {
+    } else if (base::StartsWith(origin, url::kHttpScheme,
+                                base::CompareCase::INSENSITIVE_ASCII) &&
+               base::EndsWith(origin, kHttpPortSuffix,
+                              base::CompareCase::INSENSITIVE_ASCII)) {
       jorigin = ConvertUTF8ToJavaString(
           env, origin.substr(0, origin.size() - strlen(kHttpPortSuffix)));
     } else {
diff --git a/chrome/browser/apps/guest_view/web_view_browsertest.cc b/chrome/browser/apps/guest_view/web_view_browsertest.cc
index eed661b..0019d2f 100644
--- a/chrome/browser/apps/guest_view/web_view_browsertest.cc
+++ b/chrome/browser/apps/guest_view/web_view_browsertest.cc
@@ -406,13 +406,15 @@ class WebViewTest : public extensions::PlatformAppBrowserTest {
       const std::string& path,
       const GURL& redirect_target,
       const net::test_server::HttpRequest& request) {
-    if (!base::StartsWithASCII(path, request.relative_url, true))
+    if (!base::StartsWith(path, request.relative_url,
+                          base::CompareCase::SENSITIVE))
       return scoped_ptr<net::test_server::HttpResponse>();
 
     std::map<std::string, std::string>::const_iterator it =
           request.headers.find("User-Agent");
     EXPECT_TRUE(it != request.headers.end());
-    if (!base::StartsWithASCII("foobar", it->second, true))
+    if (!base::StartsWith("foobar", it->second,
+                          base::CompareCase::SENSITIVE))
       return scoped_ptr<net::test_server::HttpResponse>();
 
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
@@ -427,7 +429,8 @@ class WebViewTest : public extensions::PlatformAppBrowserTest {
       const std::string& path,
       const GURL& redirect_target,
       const net::test_server::HttpRequest& request) {
-    if (!base::StartsWithASCII(path, request.relative_url, true))
+    if (!base::StartsWith(path, request.relative_url,
+                          base::CompareCase::SENSITIVE))
       return scoped_ptr<net::test_server::HttpResponse>();
 
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
@@ -441,7 +444,8 @@ class WebViewTest : public extensions::PlatformAppBrowserTest {
   static scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler(
       const std::string& path,
       const net::test_server::HttpRequest& request) {
-    if (base::StartsWithASCII(path, request.relative_url, true))
+    if (base::StartsWith(path, request.relative_url,
+                         base::CompareCase::SENSITIVE))
       return scoped_ptr<net::test_server::HttpResponse>(new EmptyHttpResponse);
 
     return scoped_ptr<net::test_server::HttpResponse>();
@@ -451,7 +455,8 @@ class WebViewTest : public extensions::PlatformAppBrowserTest {
   static scoped_ptr<net::test_server::HttpResponse> CacheControlResponseHandler(
       const std::string& path,
       const net::test_server::HttpRequest& request) {
-    if (!base::StartsWithASCII(path, request.relative_url, true))
+    if (!base::StartsWith(path, request.relative_url,
+                          base::CompareCase::SENSITIVE))
       return scoped_ptr<net::test_server::HttpResponse>();
 
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
diff --git a/chrome/browser/autofill/autofill_browsertest.cc b/chrome/browser/autofill/autofill_browsertest.cc
index 24101ab..69d6eaf 100644
--- a/chrome/browser/autofill/autofill_browsertest.cc
+++ b/chrome/browser/autofill/autofill_browsertest.cc
@@ -246,11 +246,11 @@ class AutofillTest : public InProcessBrowserTest {
     base::SplitString(data, '\n', &lines);
     int parsed_profiles = 0;
     for (size_t i = 0; i < lines.size(); ++i) {
-      if (base::StartsWithASCII(lines[i], "#", false))
+      if (base::StartsWith(lines[i], "#", base::CompareCase::SENSITIVE))
         continue;
 
-      std::vector<std::string> fields;
-      base::SplitString(lines[i], '|', &fields);
+      std::vector<std::string> fields = base::SplitString(
+          lines[i], "|", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       if (fields.empty())
         continue;  // Blank line.
 
diff --git a/chrome/browser/chromeos/chromeos_utils.cc b/chrome/browser/chromeos/chromeos_utils.cc
index e93a5ec9..c2e00f4 100644
--- a/chrome/browser/chromeos/chromeos_utils.cc
+++ b/chrome/browser/chromeos/chromeos_utils.cc
@@ -53,15 +53,18 @@ base::string16 GetChromeDeviceType() {
 int GetChromeDeviceTypeResourceId() {
   const std::string board = base::SysInfo::GetLsbReleaseBoard();
   for (size_t i = 0; i < arraysize(kChromeboxBoards); ++i) {
-    if (base::StartsWithASCII(board, kChromeboxBoards[i], true))
+    if (base::StartsWith(board, kChromeboxBoards[i],
+                         base::CompareCase::SENSITIVE))
       return IDS_CHROMEBOX;
   }
   for (size_t i = 0; i < arraysize(kChromebaseBoards); ++i) {
-    if (base::StartsWithASCII(board, kChromebaseBoards[i], true))
+    if (base::StartsWith(board, kChromebaseBoards[i],
+                         base::CompareCase::SENSITIVE))
       return IDS_CHROMEBASE;
   }
   for (size_t i = 0; i < arraysize(kChromebitBoards); ++i) {
-    if (base::StartsWithASCII(board, kChromebitBoards[i], true))
+    if (base::StartsWith(board, kChromebitBoards[i],
+                         base::CompareCase::SENSITIVE))
       return IDS_CHROMEBIT;
   }
   return IDS_CHROMEBOOK;
diff --git a/chrome/browser/chromeos/file_manager/file_tasks.cc b/chrome/browser/chromeos/file_manager/file_tasks.cc
index a09e9555..6d10e9c 100644
--- a/chrome/browser/chromeos/file_manager/file_tasks.cc
+++ b/chrome/browser/chromeos/file_manager/file_tasks.cc
@@ -229,7 +229,8 @@ bool ParseTaskID(const std::string& task_id, TaskDescriptor* task) {
   // identified by a prefix "drive-app:" on the extension ID. The legacy task
   // IDs can be stored in preferences.
   if (result.size() == 2) {
-    if (base::StartsWithASCII(result[0], kDriveTaskExtensionPrefix, true)) {
+    if (base::StartsWith(result[0], kDriveTaskExtensionPrefix,
+                         base::CompareCase::SENSITIVE)) {
       task->task_type = TASK_TYPE_DRIVE_APP;
       task->app_id = result[0].substr(kDriveTaskExtensionPrefixLength);
     } else {
diff --git a/chrome/browser/chromeos/input_method/input_method_engine.cc b/chrome/browser/chromeos/input_method/input_method_engine.cc
index 6bb4f86..8b73134 100644
--- a/chrome/browser/chromeos/input_method/input_method_engine.cc
+++ b/chrome/browser/chromeos/input_method/input_method_engine.cc
@@ -72,13 +72,13 @@ size_t GetUtf8StringLength(const char* s) {
 
 std::string GetKeyFromEvent(const ui::KeyEvent& event) {
   const std::string code = event.GetCodeString();
-  if (base::StartsWithASCII(code, "Control", true))
+  if (base::StartsWith(code, "Control", base::CompareCase::SENSITIVE))
     return "Ctrl";
-  if (base::StartsWithASCII(code, "Shift", true))
+  if (base::StartsWith(code, "Shift", base::CompareCase::SENSITIVE))
     return "Shift";
-  if (base::StartsWithASCII(code, "Alt", true))
+  if (base::StartsWith(code, "Alt", base::CompareCase::SENSITIVE))
     return "Alt";
-  if (base::StartsWithASCII(code, "Arrow", true))
+  if (base::StartsWith(code, "Arrow", base::CompareCase::SENSITIVE))
     return code.substr(5);
   if (code == "Escape")
     return "Esc";
diff --git a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
index d658efc..bff428c 100644
--- a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
+++ b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
@@ -70,22 +70,26 @@ InputMethodCategory GetInputMethodCategory(const std::string& input_method_id,
       extension_ime_util::GetComponentIDByInputMethodID(input_method_id);
   InputMethodCategory category = INPUT_METHOD_CATEGORY_UNKNOWN;
   char ch = 0;
-  if (base::StartsWithASCII(component_id, "xkb:", true)) {
+  if (base::StartsWith(component_id, "xkb:", base::CompareCase::SENSITIVE)) {
     ch = component_id[4];
     category = INPUT_METHOD_CATEGORY_XKB;
-  } else if (base::StartsWithASCII(component_id, "zh-", true)) {
+  } else if (base::StartsWith(component_id, "zh-",
+                              base::CompareCase::SENSITIVE)) {
     size_t pos = component_id.find("-t-i0-");
     if (pos > 0)
       pos += 6;
     ch = component_id[pos];
     category = INPUT_METHOD_CATEGORY_ZH;
-  } else if (base::StartsWithASCII(component_id, "nacl_mozc_", true)) {
+  } else if (base::StartsWith(component_id, "nacl_mozc_",
+                              base::CompareCase::SENSITIVE)) {
     ch = component_id[10];
     category = INPUT_METHOD_CATEGORY_JA;
-  } else if (base::StartsWithASCII(component_id, "hangul_", true)) {
+  } else if (base::StartsWith(component_id, "hangul_",
+                              base::CompareCase::SENSITIVE)) {
     ch = component_id[7];
     category = INPUT_METHOD_CATEGORY_KO;
-  } else if (base::StartsWithASCII(component_id, "vkd_", true)) {
+  } else if (base::StartsWith(component_id, "vkd_",
+                              base::CompareCase::SENSITIVE)) {
     ch = component_id[4];
     category = INPUT_METHOD_CATEGORY_M17N;
   } else if (component_id.find("-t-i0-") > 0) {
diff --git a/chrome/browser/chromeos/input_method/input_method_util.cc b/chrome/browser/chromeos/input_method/input_method_util.cc
index 8164932..bdd8d94 100644
--- a/chrome/browser/chromeos/input_method/input_method_util.cc
+++ b/chrome/browser/chromeos/input_method/input_method_util.cc
@@ -429,7 +429,8 @@ bool InputMethodUtil::IsValidInputMethodId(
 
 // static
 bool InputMethodUtil::IsKeyboardLayout(const std::string& input_method_id) {
-  return base::StartsWithASCII(input_method_id, "xkb:", false) ||
+  return base::StartsWith(input_method_id, "xkb:",
+                          base::CompareCase::INSENSITIVE_ASCII) ||
          extension_ime_util::IsKeyboardLayoutExtension(input_method_id);
 }
 
diff --git a/chrome/browser/chromeos/login/wizard_controller_browsertest.cc b/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
index ed4222f..3ee0699 100644
--- a/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
+++ b/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
@@ -383,16 +383,17 @@ class WizardControllerTestURLFetcherFactory
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
-    if (base::StartsWithASCII(
+    if (base::StartsWith(
             url.spec(),
             SimpleGeolocationProvider::DefaultGeolocationProviderURL().spec(),
-            true)) {
+            base::CompareCase::SENSITIVE)) {
       return scoped_ptr<net::URLFetcher>(new net::FakeURLFetcher(
           url, d, std::string(kGeolocationResponseBody), net::HTTP_OK,
           net::URLRequestStatus::SUCCESS));
     }
-    if (base::StartsWithASCII(
-            url.spec(), chromeos::DefaultTimezoneProviderURL().spec(), true)) {
+    if (base::StartsWith(url.spec(),
+                         chromeos::DefaultTimezoneProviderURL().spec(),
+                         base::CompareCase::SENSITIVE)) {
       return scoped_ptr<net::URLFetcher>(new net::FakeURLFetcher(
           url, d, std::string(kTimezoneResponseBody), net::HTTP_OK,
           net::URLRequestStatus::SUCCESS));
diff --git a/chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc b/chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc
index af19f7d..d2f131e 100644
--- a/chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc
+++ b/chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc
@@ -212,8 +212,9 @@ class UserCloudPolicyManagerChromeOSTest : public testing::Test {
     if (!fetcher)
       return NULL;
     EXPECT_TRUE(fetcher->delegate());
-    EXPECT_TRUE(base::StartsWithASCII(fetcher->GetOriginalURL().spec(),
-                                      expected_url.spec(), true));
+    EXPECT_TRUE(base::StartsWith(fetcher->GetOriginalURL().spec(),
+                                 expected_url.spec(),
+                                 base::CompareCase::SENSITIVE));
     fetcher->set_url(fetcher->GetOriginalURL());
     fetcher->set_response_code(200);
     fetcher->set_status(net::URLRequestStatus());
diff --git a/chrome/browser/chromeos/policy/variations_service_policy_browsertest.cc b/chrome/browser/chromeos/policy/variations_service_policy_browsertest.cc
index 7cb63ab..a997ec9 100644
--- a/chrome/browser/chromeos/policy/variations_service_policy_browsertest.cc
+++ b/chrome/browser/chromeos/policy/variations_service_policy_browsertest.cc
@@ -44,7 +44,8 @@ IN_PROC_BROWSER_TEST_F(VariationsServiceDevicePolicyTest, VariationsURLValid) {
   // Device policy has updated the cros settings.
   const GURL url = chrome_variations::VariationsService::GetVariationsServerURL(
       g_browser_process->local_state(), std::string());
-  EXPECT_TRUE(base::StartsWithASCII(url.spec(), default_variations_url, true));
+  EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
+                               base::CompareCase::SENSITIVE));
   std::string value;
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("restricted", value);
diff --git a/chrome/browser/chromeos/power/peripheral_battery_observer.cc b/chrome/browser/chromeos/power/peripheral_battery_observer.cc
index 8549cc0..32438ae2 100644
--- a/chrome/browser/chromeos/power/peripheral_battery_observer.cc
+++ b/chrome/browser/chromeos/power/peripheral_battery_observer.cc
@@ -49,8 +49,10 @@ const char kHIDBatteryPathPrefix[] = "/sys/class/power_supply/hid-";
 const char kHIDBatteryPathSuffix[] = "-battery";
 
 bool IsBluetoothHIDBattery(const std::string& path) {
-  return base::StartsWithASCII(path, kHIDBatteryPathPrefix, false) &&
-         base::EndsWith(path, kHIDBatteryPathSuffix, false);
+  return base::StartsWith(path, kHIDBatteryPathPrefix,
+                          base::CompareCase::INSENSITIVE_ASCII) &&
+         base::EndsWith(path, kHIDBatteryPathSuffix,
+                        base::CompareCase::INSENSITIVE_ASCII);
 }
 
 std::string ExtractBluetoothAddress(const std::string& path) {
diff --git a/chrome/browser/chromeos/proxy_cros_settings_parser.cc b/chrome/browser/chromeos/proxy_cros_settings_parser.cc
index 500e7c6..fbf315b 100644
--- a/chrome/browser/chromeos/proxy_cros_settings_parser.cc
+++ b/chrome/browser/chromeos/proxy_cros_settings_parser.cc
@@ -112,7 +112,8 @@ net::ProxyServer CreateProxyServerFromPort(
 namespace proxy_cros_settings_parser {
 
 bool IsProxyPref(const std::string& path) {
-  return base::StartsWithASCII(path, kProxyPrefsPrefix, true);
+  return base::StartsWith(path, kProxyPrefsPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 void SetProxyPrefValue(const std::string& path,
@@ -248,7 +249,8 @@ void SetProxyPrefValue(const std::string& path,
       config.SetProxyForScheme(
           "socks", CreateProxyServerFromHost(
                        val, config.socks_proxy,
-                       base::StartsWithASCII(val, "socks5://", false)
+                       base::StartsWith(val, "socks5://",
+                                        base::CompareCase::INSENSITIVE_ASCII)
                            ? net::ProxyServer::SCHEME_SOCKS5
                            : net::ProxyServer::SCHEME_SOCKS4));
     }
@@ -259,7 +261,8 @@ void SetProxyPrefValue(const std::string& path,
       config.SetProxyForScheme(
           "socks", CreateProxyServerFromPort(
                        val, config.socks_proxy,
-                       base::StartsWithASCII(host, "socks5://", false)
+                       base::StartsWith(host, "socks5://",
+                                        base::CompareCase::INSENSITIVE_ASCII)
                            ? net::ProxyServer::SCHEME_SOCKS5
                            : net::ProxyServer::SCHEME_SOCKS4));
     }
diff --git a/chrome/browser/chromeos/settings/cros_settings.cc b/chrome/browser/chromeos/settings/cros_settings.cc
index b981b37..76cc290 100644
--- a/chrome/browser/chromeos/settings/cros_settings.cc
+++ b/chrome/browser/chromeos/settings/cros_settings.cc
@@ -86,7 +86,8 @@ CrosSettings::~CrosSettings() {
 }
 
 bool CrosSettings::IsCrosSettings(const std::string& path) {
-  return base::StartsWithASCII(path, kCrosSettingsPrefix, true);
+  return base::StartsWith(path, kCrosSettingsPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 void CrosSettings::Set(const std::string& path, const base::Value& in_value) {
diff --git a/chrome/browser/chromeos/system_logs/touch_log_source_ozone.cc b/chrome/browser/chromeos/system_logs/touch_log_source_ozone.cc
index 91cafe9..e812047 100644
--- a/chrome/browser/chromeos/system_logs/touch_log_source_ozone.cc
+++ b/chrome/browser/chromeos/system_logs/touch_log_source_ozone.cc
@@ -67,7 +67,7 @@ std::string GetEventLogListOfOnePrefix(
   std::string log_list;
   for (size_t i = 0; i < log_paths.size(); ++i) {
     const std::string basename = log_paths[i].BaseName().value();
-    if (base::StartsWithASCII(basename, prefix, true)) {
+    if (base::StartsWith(basename, prefix, base::CompareCase::SENSITIVE)) {
       log_list.append(" " + log_paths[i].value());
 
       // Limit the max number of collected logs to shorten the log collection
diff --git a/chrome/browser/extensions/activity_log/activity_actions.cc b/chrome/browser/extensions/activity_log/activity_actions.cc
index 6d6db0d..2f83cbb 100644
--- a/chrome/browser/extensions/activity_log/activity_actions.cc
+++ b/chrome/browser/extensions/activity_log/activity_actions.cc
@@ -191,8 +191,8 @@ std::string Action::SerializePageUrl() const {
 }
 
 void Action::ParsePageUrl(const std::string& url) {
-  set_page_incognito(
-      base::StartsWithASCII(url, constants::kIncognitoUrl, true));
+  set_page_incognito(base::StartsWith(url, constants::kIncognitoUrl,
+                                      base::CompareCase::SENSITIVE));
   if (page_incognito())
     set_page_url(GURL(url.substr(strlen(constants::kIncognitoUrl))));
   else
@@ -204,7 +204,8 @@ std::string Action::SerializeArgUrl() const {
 }
 
 void Action::ParseArgUrl(const std::string& url) {
-  set_arg_incognito(base::StartsWithASCII(url, constants::kIncognitoUrl, true));
+  set_arg_incognito(base::StartsWith(url, constants::kIncognitoUrl,
+                                     base::CompareCase::SENSITIVE));
   if (arg_incognito())
     set_arg_url(GURL(url.substr(strlen(constants::kIncognitoUrl))));
   else
diff --git a/chrome/browser/extensions/activity_log/activity_log.cc b/chrome/browser/extensions/activity_log/activity_log.cc
index 6a8263c..d160b7e 100644
--- a/chrome/browser/extensions/activity_log/activity_log.cc
+++ b/chrome/browser/extensions/activity_log/activity_log.cc
@@ -521,7 +521,8 @@ void ActivityLog::LogAction(scoped_refptr<Action> action) {
 
   // Mark DOM XHR requests as such, for easier processing later.
   if (action->action_type() == Action::ACTION_DOM_ACCESS &&
-      base::StartsWithASCII(action->api_name(), kDomXhrPrefix, true) &&
+      base::StartsWith(action->api_name(), kDomXhrPrefix,
+                       base::CompareCase::SENSITIVE) &&
       action->other()) {
     base::DictionaryValue* other = action->mutable_other();
     int dom_verb = -1;
diff --git a/chrome/browser/extensions/api/commands/command_service.cc b/chrome/browser/extensions/api/commands/command_service.cc
index 0f57c60..7636c93 100644
--- a/chrome/browser/extensions/api/commands/command_service.cc
+++ b/chrome/browser/extensions/api/commands/command_service.cc
@@ -69,7 +69,8 @@ std::string GetPlatformKeybindingKeyForAccelerator(
 }
 
 bool IsForCurrentPlatform(const std::string& key) {
-  return base::StartsWithASCII(key, Command::CommandPlatform() + ":", true);
+  return base::StartsWith(key, Command::CommandPlatform() + ":",
+                          base::CompareCase::SENSITIVE);
 }
 
 std::string StripCurrentPlatform(const std::string& key) {
diff --git a/chrome/browser/extensions/api/extension_action/extension_action_api.cc b/chrome/browser/extensions/api/extension_action/extension_action_api.cc
index efbb40e..917d42d 100644
--- a/chrome/browser/extensions/api/extension_action/extension_action_api.cc
+++ b/chrome/browser/extensions/api/extension_action/extension_action_api.cc
@@ -377,7 +377,8 @@ ExtensionActionFunction::~ExtensionActionFunction() {
 
 bool ExtensionActionFunction::RunSync() {
   ExtensionActionManager* manager = ExtensionActionManager::Get(GetProfile());
-  if (base::StartsWithASCII(name(), "systemIndicator.", false)) {
+  if (base::StartsWith(name(), "systemIndicator.",
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     extension_action_ = manager->GetSystemIndicator(*extension());
   } else {
     extension_action_ = manager->GetBrowserAction(*extension());
diff --git a/chrome/browser/extensions/api/feedback_private/feedback_private_api.cc b/chrome/browser/extensions/api/feedback_private/feedback_private_api.cc
index 44b162e..ad56efd 100644
--- a/chrome/browser/extensions/api/feedback_private/feedback_private_api.cc
+++ b/chrome/browser/extensions/api/feedback_private/feedback_private_api.cc
@@ -31,7 +31,8 @@ namespace {
 // This is undesirable, strip it if it exists.
 std::string StripFakepath(const std::string& path) {
   const char kFakePathStr[] = "C:\\fakepath\\";
-  if (base::StartsWithASCII(path, kFakePathStr, false))
+  if (base::StartsWith(path, kFakePathStr,
+                       base::CompareCase::INSENSITIVE_ASCII))
     return path.substr(arraysize(kFakePathStr) - 1);
   return path;
 }
diff --git a/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc b/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
index 3301db8..6b7232e 100644
--- a/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
+++ b/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
@@ -179,7 +179,8 @@ void GaiaWebAuthFlow::OnAuthFlowURLChange(const GURL& url) {
   // interpreted as a path, including the fragment.
 
   if (url.scheme() == redirect_scheme_ && !url.has_host() && !url.has_port() &&
-      base::StartsWithASCII(url.GetContent(), redirect_path_prefix_, true)) {
+      base::StartsWith(url.GetContent(), redirect_path_prefix_,
+                       base::CompareCase::SENSITIVE)) {
     web_flow_.release()->DetachDelegateAndDelete();
 
     std::string fragment = url.GetContent().substr(
@@ -223,7 +224,7 @@ void GaiaWebAuthFlow::OnAuthFlowTitleChange(const std::string& title) {
   const char kRedirectPrefix[] = "Loading ";
   std::string prefix(kRedirectPrefix);
 
-  if (base::StartsWithASCII(title, prefix, true)) {
+  if (base::StartsWith(title, prefix, base::CompareCase::SENSITIVE)) {
     GURL url(title.substr(prefix.length(), std::string::npos));
     if (url.is_valid())
       OnAuthFlowURLChange(url);
diff --git a/chrome/browser/extensions/api/identity/identity_apitest.cc b/chrome/browser/extensions/api/identity/identity_apitest.cc
index 93d8c8d..3d358ad 100644
--- a/chrome/browser/extensions/api/identity/identity_apitest.cc
+++ b/chrome/browser/extensions/api/identity/identity_apitest.cc
@@ -801,7 +801,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE);
   std::string error =
       utils::RunFunctionAndReturnError(func.get(), "[{}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -814,7 +815,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_login_access_token_result(false);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
@@ -843,7 +845,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
       TestOAuth2MintTokenFlow::MINT_TOKEN_BAD_CREDENTIALS);
   std::string error =
       utils::RunFunctionAndReturnError(func.get(), "[{}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -857,7 +860,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
       TestOAuth2MintTokenFlow::MINT_TOKEN_SERVICE_ERROR);
   std::string error =
       utils::RunFunctionAndReturnError(func.get(), "[{}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -959,7 +963,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_TRUE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -972,7 +977,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_login_access_token_result(false);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_TRUE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -1076,7 +1082,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_scope_ui_failure(GaiaWebAuthFlow::SERVICE_AUTH_ERROR);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_TRUE(func->scope_ui_shown());
 }
@@ -1498,7 +1505,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"account\": { \"id\": \"2\" } }]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 }
@@ -1515,7 +1523,8 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
   func->set_login_access_token_result(false);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"account\": { \"id\": \"2\" } }]", browser());
-  EXPECT_TRUE(base::StartsWithASCII(error, errors::kAuthFailure, false));
+  EXPECT_TRUE(base::StartsWith(error, errors::kAuthFailure,
+                               base::CompareCase::INSENSITIVE_ASCII));
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
diff --git a/chrome/browser/extensions/blob_reader.cc b/chrome/browser/extensions/blob_reader.cc
index 33ec632..dbcc212 100644
--- a/chrome/browser/extensions/blob_reader.cc
+++ b/chrome/browser/extensions/blob_reader.cc
@@ -21,7 +21,8 @@ BlobReader::BlobReader(Profile* profile,
     : callback_(callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   GURL blob_url;
-  if (base::StartsWithASCII(blob_uuid, "blob:blobinternal", true)) {
+  if (base::StartsWith(blob_uuid, "blob:blobinternal",
+                       base::CompareCase::SENSITIVE)) {
     // TODO(michaeln): remove support for deprecated blob urls
     blob_url = GURL(blob_uuid);
   } else {
diff --git a/chrome/browser/extensions/chrome_url_request_util.cc b/chrome/browser/extensions/chrome_url_request_util.cc
index fcfa3a5..60d1eb6 100644
--- a/chrome/browser/extensions/chrome_url_request_util.cc
+++ b/chrome/browser/extensions/chrome_url_request_util.cc
@@ -98,7 +98,8 @@ class URLRequestResourceBundleJob : public net::URLRequestSimpleJob {
                       const net::CompletionCallback& callback,
                       bool read_result) {
     *out_mime_type = *read_mime_type;
-    if (base::StartsWithASCII(*read_mime_type, "text/", false)) {
+    if (base::StartsWith(*read_mime_type, "text/",
+                         base::CompareCase::INSENSITIVE_ASCII)) {
       // All of our HTML files should be UTF-8 and for other resource types
       // (like images), charset doesn't matter.
       DCHECK(base::IsStringUTF8(base::StringPiece(
diff --git a/chrome/browser/extensions/extension_apitest.cc b/chrome/browser/extensions/extension_apitest.cc
index febd096..46544fb 100644
--- a/chrome/browser/extensions/extension_apitest.cc
+++ b/chrome/browser/extensions/extension_apitest.cc
@@ -41,7 +41,8 @@ const char kSpawnedTestServerPort[] = "spawnedTestServer.port";
 
 scoped_ptr<net::test_server::HttpResponse> HandleServerRedirectRequest(
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/server-redirect?", true))
+  if (!base::StartsWith(request.relative_url, "/server-redirect?",
+                        base::CompareCase::SENSITIVE))
     return nullptr;
 
   size_t query_string_pos = request.relative_url.find('?');
@@ -57,7 +58,8 @@ scoped_ptr<net::test_server::HttpResponse> HandleServerRedirectRequest(
 
 scoped_ptr<net::test_server::HttpResponse> HandleEchoHeaderRequest(
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/echoheader?", true))
+  if (!base::StartsWith(request.relative_url, "/echoheader?",
+                        base::CompareCase::SENSITIVE))
     return nullptr;
 
   size_t query_string_pos = request.relative_url.find('?');
@@ -79,7 +81,8 @@ scoped_ptr<net::test_server::HttpResponse> HandleEchoHeaderRequest(
 
 scoped_ptr<net::test_server::HttpResponse> HandleSetCookieRequest(
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/set-cookie?", true))
+  if (!base::StartsWith(request.relative_url, "/set-cookie?",
+                        base::CompareCase::SENSITIVE))
     return nullptr;
 
   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
@@ -101,7 +104,8 @@ scoped_ptr<net::test_server::HttpResponse> HandleSetCookieRequest(
 
 scoped_ptr<net::test_server::HttpResponse> HandleSetHeaderRequest(
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/set-header?", true))
+  if (!base::StartsWith(request.relative_url, "/set-header?",
+                        base::CompareCase::SENSITIVE))
     return nullptr;
 
   size_t query_string_pos = request.relative_url.find('?');
diff --git a/chrome/browser/extensions/extension_install_ui_browsertest.cc b/chrome/browser/extensions/extension_install_ui_browsertest.cc
index dcebd09..21e0479 100644
--- a/chrome/browser/extensions/extension_install_ui_browsertest.cc
+++ b/chrome/browser/extensions/extension_install_ui_browsertest.cc
@@ -161,8 +161,9 @@ IN_PROC_BROWSER_TEST_F(ExtensionInstallUIBrowserTest,
     WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(web_contents);
-    EXPECT_TRUE(base::StartsWithASCII(web_contents->GetURL().spec(),
-                                      "chrome://newtab/", false));
+    EXPECT_TRUE(base::StartsWith(web_contents->GetURL().spec(),
+                                 "chrome://newtab/",
+                                 base::CompareCase::INSENSITIVE_ASCII));
   } else {
     // TODO(xiyuan): Figure out how to test extension installed bubble?
   }
@@ -187,8 +188,9 @@ IN_PROC_BROWSER_TEST_F(ExtensionInstallUIBrowserTest,
     WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(web_contents);
-    EXPECT_TRUE(base::StartsWithASCII(web_contents->GetURL().spec(),
-                                      "chrome://newtab/", false));
+    EXPECT_TRUE(base::StartsWith(web_contents->GetURL().spec(),
+                                 "chrome://newtab/",
+                                 base::CompareCase::INSENSITIVE_ASCII));
   } else {
     // TODO(xiyuan): Figure out how to test extension installed bubble?
   }
diff --git a/chrome/browser/extensions/extension_management.cc b/chrome/browser/extensions/extension_management.cc
index d46eacd..7dab6756 100644
--- a/chrome/browser/extensions/extension_management.cc
+++ b/chrome/browser/extensions/extension_management.cc
@@ -374,8 +374,8 @@ void ExtensionManagement::Refresh() {
         continue;
       if (!iter.value().GetAsDictionary(&subdict))
         continue;
-      if (base::StartsWithASCII(iter.key(), schema_constants::kUpdateUrlPrefix,
-                                true)) {
+      if (base::StartsWith(iter.key(), schema_constants::kUpdateUrlPrefix,
+                           base::CompareCase::SENSITIVE)) {
         const std::string& update_url =
             iter.key().substr(strlen(schema_constants::kUpdateUrlPrefix));
         if (!GURL(update_url).is_valid()) {
diff --git a/chrome/browser/extensions/extension_protocols_unittest.cc b/chrome/browser/extensions/extension_protocols_unittest.cc
index ab30636..e057b04 100644
--- a/chrome/browser/extensions/extension_protocols_unittest.cc
+++ b/chrome/browser/extensions/extension_protocols_unittest.cc
@@ -298,8 +298,8 @@ TEST_F(ExtensionProtocolTest, ResourceRequestResponseHeaders) {
     // Check that cache-related headers are set.
     std::string etag;
     request->GetResponseHeaderByName("ETag", &etag);
-    EXPECT_TRUE(base::StartsWithASCII(etag, "\"", false));
-    EXPECT_TRUE(base::EndsWith(etag, "\"", false));
+    EXPECT_TRUE(base::StartsWith(etag, "\"", base::CompareCase::SENSITIVE));
+    EXPECT_TRUE(base::EndsWith(etag, "\"", base::CompareCase::SENSITIVE));
 
     std::string revalidation_header;
     request->GetResponseHeaderByName("cache-control", &revalidation_header);
diff --git a/chrome/browser/extensions/extension_request_limiting_throttle_browsertest.cc b/chrome/browser/extensions/extension_request_limiting_throttle_browsertest.cc
index be0b013..cff9345 100644
--- a/chrome/browser/extensions/extension_request_limiting_throttle_browsertest.cc
+++ b/chrome/browser/extensions/extension_request_limiting_throttle_browsertest.cc
@@ -27,7 +27,8 @@ scoped_ptr<net::test_server::HttpResponse> HandleRequest(
     bool set_cache_header_redirect_page,
     bool set_cache_header_test_throttle_page,
     const net::test_server::HttpRequest& request) {
-  if (base::StartsWithASCII(request.relative_url, "/redirect", true)) {
+  if (base::StartsWith(request.relative_url, "/redirect",
+                       base::CompareCase::SENSITIVE)) {
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_code(net::HTTP_FOUND);
@@ -39,7 +40,8 @@ scoped_ptr<net::test_server::HttpResponse> HandleRequest(
     return http_response.Pass();
   }
 
-  if (base::StartsWithASCII(request.relative_url, "/test_throttle", true)) {
+  if (base::StartsWith(request.relative_url, "/test_throttle",
+                       base::CompareCase::SENSITIVE)) {
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_code(net::HTTP_SERVICE_UNAVAILABLE);
diff --git a/chrome/browser/extensions/extension_web_ui.cc b/chrome/browser/extensions/extension_web_ui.cc
index 2b30e03..2ad1696 100644
--- a/chrome/browser/extensions/extension_web_ui.cc
+++ b/chrome/browser/extensions/extension_web_ui.cc
@@ -285,7 +285,8 @@ bool ExtensionWebUI::HandleChromeURLOverrideReverse(
       std::string override;
       if (!(*it2)->GetAsString(&override))
         continue;
-      if (base::StartsWithASCII(url->spec(), override, true)) {
+      if (base::StartsWith(url->spec(), override,
+                           base::CompareCase::SENSITIVE)) {
         GURL original_url(content::kChromeUIScheme + std::string("://") +
                           it.key() + url->spec().substr(override.length()));
         *url = original_url;
diff --git a/chrome/browser/extensions/isolated_app_browsertest.cc b/chrome/browser/extensions/isolated_app_browsertest.cc
index f7b1b1e..c9439ef 100644
--- a/chrome/browser/extensions/isolated_app_browsertest.cc
+++ b/chrome/browser/extensions/isolated_app_browsertest.cc
@@ -42,8 +42,8 @@ std::string WrapForJavascriptAndExtract(const char* javascript_expression) {
 scoped_ptr<net::test_server::HttpResponse> HandleExpectAndSetCookieRequest(
     const net::test_server::EmbeddedTestServer* test_server,
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/expect-and-set-cookie?",
-                             true))
+  if (!base::StartsWith(request.relative_url, "/expect-and-set-cookie?",
+                        base::CompareCase::SENSITIVE))
     return scoped_ptr<net::test_server::HttpResponse>();
 
   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
diff --git a/chrome/browser/google/google_brand.cc b/chrome/browser/google/google_brand.cc
index 894efb5..516918d 100644
--- a/chrome/browser/google/google_brand.cc
+++ b/chrome/browser/google/google_brand.cc
@@ -103,9 +103,9 @@ bool IsOrganic(const std::string& brand) {
   if (found != end)
     return true;
 
-  return base::StartsWithASCII(brand, "EUB", true) ||
-         base::StartsWithASCII(brand, "EUC", true) ||
-         base::StartsWithASCII(brand, "GGR", true);
+  return base::StartsWith(brand, "EUB", base::CompareCase::SENSITIVE) ||
+         base::StartsWith(brand, "EUC", base::CompareCase::SENSITIVE) ||
+         base::StartsWith(brand, "GGR", base::CompareCase::SENSITIVE);
 }
 
 bool IsOrganicFirstRun(const std::string& brand) {
@@ -117,8 +117,8 @@ bool IsOrganicFirstRun(const std::string& brand) {
   }
 #endif
 
-  return base::StartsWithASCII(brand, "GG", true) ||
-         base::StartsWithASCII(brand, "EU", true);
+  return base::StartsWith(brand, "GG", base::CompareCase::SENSITIVE) ||
+         base::StartsWith(brand, "EU", base::CompareCase::SENSITIVE);
 }
 
 bool IsInternetCafeBrandCode(const std::string& brand) {
diff --git a/chrome/browser/local_discovery/device_description.cc b/chrome/browser/local_discovery/device_description.cc
index b9a3dda..f3bd497 100644
--- a/chrome/browser/local_discovery/device_description.cc
+++ b/chrome/browser/local_discovery/device_description.cc
@@ -19,7 +19,8 @@ std::string GetValueByName(const std::vector<std::string>& metadata,
                            const std::string& name) {
   std::string prefix(name + "=");
   for (const std::string& record : metadata) {
-    if (base::StartsWithASCII(record, prefix, false)) {
+    if (base::StartsWith(record, prefix,
+                         base::CompareCase::INSENSITIVE_ASCII)) {
       return record.substr(prefix.size());
     }
   }
diff --git a/chrome/browser/media/router/media_source_helper.cc b/chrome/browser/media/router/media_source_helper.cc
index a5d1288..629160f 100644
--- a/chrome/browser/media/router/media_source_helper.cc
+++ b/chrome/browser/media/router/media_source_helper.cc
@@ -34,13 +34,16 @@ MediaSource MediaSourceForPresentationUrl(const std::string& presentation_url) {
 }
 
 bool IsMirroringMediaSource(const MediaSource& source) {
-  return base::StartsWithASCII(source.id(), kDesktopMediaUrn, true) ||
-         base::StartsWithASCII(source.id(), kTabMediaUrnPrefix, true);
+  return base::StartsWith(source.id(), kDesktopMediaUrn,
+                          base::CompareCase::SENSITIVE) ||
+         base::StartsWith(source.id(), kTabMediaUrnPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 bool IsValidMediaSource(const MediaSource& source) {
   if (IsMirroringMediaSource(source) ||
-      base::StartsWithASCII(source.id(), kCastUrnPrefix, true)) {
+      base::StartsWith(source.id(), kCastUrnPrefix,
+                       base::CompareCase::SENSITIVE)) {
     return true;
   }
   GURL url(source.id());
diff --git a/chrome/browser/media/webrtc_browsertest_base.cc b/chrome/browser/media/webrtc_browsertest_base.cc
index 7245821..52707eb 100644
--- a/chrome/browser/media/webrtc_browsertest_base.cc
+++ b/chrome/browser/media/webrtc_browsertest_base.cc
@@ -292,7 +292,7 @@ std::string WebRtcTestBase::GetStreamSize(
   std::string javascript =
       base::StringPrintf("getStreamSize('%s')", video_element.c_str());
   std::string result = ExecuteJavascript(javascript, tab_contents);
-  EXPECT_TRUE(base::StartsWithASCII(result, "ok-", true));
+  EXPECT_TRUE(base::StartsWith(result, "ok-", base::CompareCase::SENSITIVE));
   return result.substr(3);
 }
 
diff --git a/chrome/browser/media/webrtc_browsertest_common.cc b/chrome/browser/media/webrtc_browsertest_common.cc
index 61f967e..d67a699 100644
--- a/chrome/browser/media/webrtc_browsertest_common.cc
+++ b/chrome/browser/media/webrtc_browsertest_common.cc
@@ -40,7 +40,8 @@ static const char kAdviseOnGclientSolution[] =
 const int kDefaultPollIntervalMsec = 250;
 
 bool IsErrorResult(const std::string& result) {
-  return base::StartsWithASCII(result, "failed-", false);
+  return base::StartsWith(result, "failed-",
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 base::FilePath GetReferenceFilesDir() {
diff --git a/chrome/browser/media_galleries/fileapi/media_file_system_backend.cc b/chrome/browser/media_galleries/fileapi/media_file_system_backend.cc
index def7bdf7..4768342 100644
--- a/chrome/browser/media_galleries/fileapi/media_file_system_backend.cc
+++ b/chrome/browser/media_galleries/fileapi/media_file_system_backend.cc
@@ -94,7 +94,8 @@ void AttemptAutoMountOnUIThread(
             profile->GetPath(), storage_domain, kInvalidMediaGalleryPrefId);
     MediaGalleryPrefId pref_id = kInvalidMediaGalleryPrefId;
     if (extension && extension->id() == storage_domain &&
-        base::StartsWithASCII(mount_point, expected_mount_prefix, true) &&
+        base::StartsWith(mount_point, expected_mount_prefix,
+                         base::CompareCase::SENSITIVE) &&
         base::StringToUint64(mount_point.substr(expected_mount_prefix.size()),
                              &pref_id) &&
         pref_id != kInvalidMediaGalleryPrefId) {
@@ -198,7 +199,8 @@ bool MediaFileSystemBackend::AttemptAutoMountForURLRequest(
   if (components.empty())
     return false;
   std::string mount_point = base::FilePath(components[0]).AsUTF8Unsafe();
-  if (!base::StartsWithASCII(mount_point, kMediaGalleryMountPrefix, true))
+  if (!base::StartsWith(mount_point, kMediaGalleryMountPrefix,
+                        base::CompareCase::SENSITIVE))
     return false;
 
   const content::ResourceRequestInfo* request_info =
diff --git a/chrome/browser/media_galleries/fileapi/native_media_file_util.cc b/chrome/browser/media_galleries/fileapi/native_media_file_util.cc
index 87acf8c..05a3b53 100644
--- a/chrome/browser/media_galleries/fileapi/native_media_file_util.cc
+++ b/chrome/browser/media_galleries/fileapi/native_media_file_util.cc
@@ -37,9 +37,9 @@ base::File::Error IsMediaHeader(const char* buf, size_t length) {
   if (!net::SniffMimeTypeFromLocalData(buf, length, &mime_type))
     return base::File::FILE_ERROR_SECURITY;
 
-  if (base::StartsWithASCII(mime_type, "image/", true) ||
-      base::StartsWithASCII(mime_type, "audio/", true) ||
-      base::StartsWithASCII(mime_type, "video/", true) ||
+  if (base::StartsWith(mime_type, "image/", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(mime_type, "audio/", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(mime_type, "video/", base::CompareCase::SENSITIVE) ||
       mime_type == "application/x-shockwave-flash") {
     return base::File::FILE_OK;
   }
diff --git a/chrome/browser/media_galleries/media_folder_finder.cc b/chrome/browser/media_galleries/media_folder_finder.cc
index b80b1bf..26ec50eb 100644
--- a/chrome/browser/media_galleries/media_folder_finder.cc
+++ b/chrome/browser/media_galleries/media_folder_finder.cc
@@ -98,8 +98,8 @@ bool ShouldIgnoreScanRoot(const base::FilePath& path) {
   return mount_point.IsParent(path);
 #elif defined(OS_LINUX)
   // /media and /mnt are likely the only places with interesting mount points.
-  if (base::StartsWithASCII(path.value(), "/media", true) ||
-      base::StartsWithASCII(path.value(), "/mnt", true)) {
+  if (base::StartsWith(path.value(), "/media", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(path.value(), "/mnt", base::CompareCase::SENSITIVE)) {
     return false;
   }
   return true;
diff --git a/chrome/browser/metrics/variations/variations_service_unittest.cc b/chrome/browser/metrics/variations/variations_service_unittest.cc
index 1741572..d01707e 100644
--- a/chrome/browser/metrics/variations/variations_service_unittest.cc
+++ b/chrome/browser/metrics/variations/variations_service_unittest.cc
@@ -243,18 +243,21 @@ TEST_F(VariationsServiceTest, GetVariationsServerURL) {
 
   std::string value;
   GURL url = VariationsService::GetVariationsServerURL(prefs, std::string());
-  EXPECT_TRUE(base::StartsWithASCII(url.spec(), default_variations_url, true));
+  EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
+                               base::CompareCase::SENSITIVE));
   EXPECT_FALSE(net::GetValueForKeyInQuery(url, "restrict", &value));
 
   prefs_store.SetVariationsRestrictParameterPolicyValue("restricted");
   url = VariationsService::GetVariationsServerURL(prefs, std::string());
-  EXPECT_TRUE(base::StartsWithASCII(url.spec(), default_variations_url, true));
+  EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
+                               base::CompareCase::SENSITIVE));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("restricted", value);
 
   // The override value should take precedence over what's in prefs.
   url = VariationsService::GetVariationsServerURL(prefs, "override");
-  EXPECT_TRUE(base::StartsWithASCII(url.spec(), default_variations_url, true));
+  EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
+                               base::CompareCase::SENSITIVE));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("override", value);
 }
diff --git a/chrome/browser/net/async_dns_field_trial.cc b/chrome/browser/net/async_dns_field_trial.cc
index ab4f704..b8ce85fd 100644
--- a/chrome/browser/net/async_dns_field_trial.cc
+++ b/chrome/browser/net/async_dns_field_trial.cc
@@ -79,8 +79,8 @@ bool ConfigureAsyncDnsFieldTrial() {
   // otherwise (trial absent): return default.
   std::string group_name = base::FieldTrialList::FindFullName("AsyncDns");
   if (!group_name.empty()) {
-    const bool enabled = base::StartsWithASCII(group_name, "AsyncDns",
-                                               false /* case_sensitive */);
+    const bool enabled = base::StartsWith(group_name, "AsyncDns",
+                                          base::CompareCase::INSENSITIVE_ASCII);
     HistogramPrefDefaultSource(FIELD_TRIAL, enabled);
     return enabled;
   }
diff --git a/chrome/browser/net/chrome_network_delegate.cc b/chrome/browser/net/chrome_network_delegate.cc
index 1975b78..c604207 100644
--- a/chrome/browser/net/chrome_network_delegate.cc
+++ b/chrome/browser/net/chrome_network_delegate.cc
@@ -174,7 +174,6 @@ bool CanRequestBeDeltaEncoded(const net::URLRequest* request) {
     // XML (application/xml and application/*+xml) is eligible.
     { "application/", "xml" },
   };
-  const bool kCaseSensitive = true;
 
   std::string mime_type;
   request->GetMimeType(&mime_type);
@@ -182,9 +181,11 @@ bool CanRequestBeDeltaEncoded(const net::URLRequest* request) {
   for (size_t i = 0; i < arraysize(kEligibleMasks); i++) {
     const char *prefix = kEligibleMasks[i].prefix;
     const char *suffix = kEligibleMasks[i].suffix;
-    if (prefix && !base::StartsWithASCII(mime_type, prefix, kCaseSensitive))
+    if (prefix &&
+        !base::StartsWith(mime_type, prefix, base::CompareCase::SENSITIVE))
       continue;
-    if (suffix && !base::EndsWith(mime_type, suffix, kCaseSensitive))
+    if (suffix &&
+        !base::EndsWith(mime_type, suffix, base::CompareCase::SENSITIVE))
       continue;
     return true;
   }
diff --git a/chrome/browser/net/safe_search_util.cc b/chrome/browser/net/safe_search_util.cc
index 86862cd..9e34a64 100644
--- a/chrome/browser/net/safe_search_util.cc
+++ b/chrome/browser/net/safe_search_util.cc
@@ -38,7 +38,8 @@ bool HasSameParameterKey(const std::string& first_parameter,
   // Prefix for "foo=bar" is "foo=".
   std::string parameter_prefix = second_parameter.substr(
       0, second_parameter.find("=") + 1);
-  return base::StartsWithASCII(first_parameter, parameter_prefix, false);
+  return base::StartsWith(first_parameter, parameter_prefix,
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 // Examines the query string containing parameters and adds the necessary ones
diff --git a/chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc b/chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc
index a45f583..0459ded 100644
--- a/chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc
+++ b/chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc
@@ -67,7 +67,8 @@ bool GetEmbeddedPacScript(const std::string& pac_url, std::string* pac_script) {
   DCHECK(pac_script);
   const std::string kPacURLPrefix =
       "data:application/x-ns-proxy-autoconfig;base64,";
-  return base::StartsWithASCII(pac_url, kPacURLPrefix, true) &&
+  return base::StartsWith(pac_url, kPacURLPrefix,
+                          base::CompareCase::SENSITIVE) &&
          base::Base64Decode(pac_url.substr(kPacURLPrefix.size()), pac_script);
 }
 
diff --git a/chrome/browser/password_manager/password_manager_browsertest.cc b/chrome/browser/password_manager/password_manager_browsertest.cc
index 6a6416b..2858121 100644
--- a/chrome/browser/password_manager/password_manager_browsertest.cc
+++ b/chrome/browser/password_manager/password_manager_browsertest.cc
@@ -271,7 +271,8 @@ scoped_ptr<PromptObserver> PromptObserver::Create(
 // serves a Basic Auth challenge.
 scoped_ptr<net::test_server::HttpResponse> HandleTestAuthRequest(
     const net::test_server::HttpRequest& request) {
-  if (!base::StartsWithASCII(request.relative_url, "/basic_auth", true))
+  if (!base::StartsWith(request.relative_url, "/basic_auth",
+                        base::CompareCase::SENSITIVE))
     return scoped_ptr<net::test_server::HttpResponse>();
 
   if (ContainsKey(request.headers, "Authorization")) {
diff --git a/chrome/browser/plugins/plugin_info_message_filter.cc b/chrome/browser/plugins/plugin_info_message_filter.cc
index b0337f2..8e4a119b 100644
--- a/chrome/browser/plugins/plugin_info_message_filter.cc
+++ b/chrome/browser/plugins/plugin_info_message_filter.cc
@@ -129,8 +129,9 @@ void ReportMetrics(const std::string& mime_type,
   if (!rappor_service)
     return;
 
-  if (base::StartsWithASCII(mime_type,
-                            content::kSilverlightPluginMimeTypePrefix, false)) {
+  if (base::StartsWith(mime_type,
+                       content::kSilverlightPluginMimeTypePrefix,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     rappor_service->RecordSample(
         "Plugins.SilverlightOriginUrl", rappor::ETLD_PLUS_ONE_RAPPOR_TYPE,
         net::registry_controlled_domains::GetDomainAndRegistry(
diff --git a/chrome/browser/policy/policy_browsertest.cc b/chrome/browser/policy/policy_browsertest.cc
index 644be40..cc30765 100644
--- a/chrome/browser/policy/policy_browsertest.cc
+++ b/chrome/browser/policy/policy_browsertest.cc
@@ -3780,7 +3780,8 @@ IN_PROC_BROWSER_TEST_F(PolicyVariationsServiceTest, VariationsURLIsValid) {
   const GURL url =
       chrome_variations::VariationsService::GetVariationsServerURL(
           g_browser_process->local_state(), std::string());
-  EXPECT_TRUE(base::StartsWithASCII(url.spec(), default_variations_url, true));
+  EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
+                               base::CompareCase::SENSITIVE));
   std::string value;
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("restricted", value);
diff --git a/chrome/browser/policy/policy_prefs_browsertest.cc b/chrome/browser/policy/policy_prefs_browsertest.cc
index bd53790..503c5f9 100644
--- a/chrome/browser/policy/policy_prefs_browsertest.cc
+++ b/chrome/browser/policy/policy_prefs_browsertest.cc
@@ -559,8 +559,8 @@ IN_PROC_BROWSER_TEST_F(PolicyPrefsTest, PolicyToPrefsMapping) {
            ++pref_mapping) {
         // Skip Chrome OS preferences that use a different backend and cannot be
         // retrieved through the prefs mechanism.
-        if (base::StartsWithASCII((*pref_mapping)->pref(), kCrosSettingsPrefix,
-                                  true))
+        if (base::StartsWith((*pref_mapping)->pref(), kCrosSettingsPrefix,
+                             base::CompareCase::SENSITIVE))
           continue;
 
         // Skip preferences that should not be checked when the policy is set to
diff --git a/chrome/browser/predictors/autocomplete_action_predictor.cc b/chrome/browser/predictors/autocomplete_action_predictor.cc
index 983f73b..15035b2 100644
--- a/chrome/browser/predictors/autocomplete_action_predictor.cc
+++ b/chrome/browser/predictors/autocomplete_action_predictor.cc
@@ -344,7 +344,8 @@ void AutocompleteActionPredictor::OnOmniboxOpenedUrl(const OmniboxLog& log) {
   for (std::vector<TransitionalMatch>::const_iterator it =
         transitional_matches_.begin(); it != transitional_matches_.end();
         ++it) {
-    if (!base::StartsWith(lower_user_text, it->user_text, true))
+    if (!base::StartsWith(lower_user_text, it->user_text,
+                          base::CompareCase::SENSITIVE))
       continue;
 
     // Add entries to the database for those matches.
diff --git a/chrome/browser/predictors/autocomplete_action_predictor_unittest.cc b/chrome/browser/predictors/autocomplete_action_predictor_unittest.cc
index 00562c6..8c22385 100644
--- a/chrome/browser/predictors/autocomplete_action_predictor_unittest.cc
+++ b/chrome/browser/predictors/autocomplete_action_predictor_unittest.cc
@@ -322,7 +322,8 @@ TEST_F(AutocompleteActionPredictorTest, DeleteOldIdsFromCaches) {
     all_ids.push_back(row_id);
 
     bool exclude_url =
-        base::StartsWithASCII(test_url_db[i].url.path(), "/d", true) ||
+        base::StartsWith(test_url_db[i].url.path(), "/d",
+                         base::CompareCase::SENSITIVE) ||
         (test_url_db[i].days_from_now > maximum_days_to_keep_entry());
 
     if (exclude_url)
diff --git a/chrome/browser/prefetch/prefetch_field_trial.cc b/chrome/browser/prefetch/prefetch_field_trial.cc
index e51dcb3..f984a3a 100644
--- a/chrome/browser/prefetch/prefetch_field_trial.cc
+++ b/chrome/browser/prefetch/prefetch_field_trial.cc
@@ -14,7 +14,8 @@ namespace prefetch {
 
 bool DisableForFieldTrial() {
   std::string experiment = base::FieldTrialList::FindFullName("Prefetch");
-  return base::StartsWithASCII(experiment, "ExperimentDisable", false);
+  return base::StartsWith(experiment, "ExperimentDisable",
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 }  // namespace prefetch
diff --git a/chrome/browser/prefs/tracked/pref_hash_browsertest.cc b/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
index 48d4bfe..d11ba30 100644
--- a/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
+++ b/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
@@ -309,9 +309,9 @@ class PrefHashBrowserTestBase
  private:
   // Returns true if this is the PRE_ phase of the test.
   bool IsPRETest() {
-    return base::StartsWithASCII(
+    return base::StartsWith(
         testing::UnitTest::GetInstance()->current_test_info()->name(), "PRE_",
-        true /* case_sensitive */);
+        base::CompareCase::SENSITIVE);
   }
 
   SettingsProtectionLevel GetProtectionLevelFromTrialGroup(
diff --git a/chrome/browser/prerender/prerender_util.cc b/chrome/browser/prerender/prerender_util.cc
index 1b60fcb..e708cfdb 100644
--- a/chrome/browser/prerender/prerender_util.cc
+++ b/chrome/browser/prerender/prerender_util.cc
@@ -72,16 +72,18 @@ bool MaybeGetQueryStringBasedAliasURL(
 }
 
 bool IsGoogleDomain(const GURL& url) {
-  return base::StartsWithASCII(url.host(), std::string("www.google."), true);
+  return base::StartsWith(url.host(), "www.google.",
+                          base::CompareCase::SENSITIVE);
 }
 
 bool IsGoogleSearchResultURL(const GURL& url) {
   if (!IsGoogleDomain(url))
     return false;
   return (url.path().empty() ||
-          base::StartsWithASCII(url.path(), std::string("/search"), true) ||
+          base::StartsWith(url.path(), "/search",
+                           base::CompareCase::SENSITIVE) ||
           (url.path() == "/") ||
-          base::StartsWithASCII(url.path(), std::string("/webhp"), true));
+          base::StartsWith(url.path(), "/webhp", base::CompareCase::SENSITIVE));
 }
 
 void ReportPrerenderExternalURL() {
diff --git a/chrome/browser/profile_resetter/automatic_profile_resetter.cc b/chrome/browser/profile_resetter/automatic_profile_resetter.cc
index f932946..e6c886d 100644
--- a/chrome/browser/profile_resetter/automatic_profile_resetter.cc
+++ b/chrome/browser/profile_resetter/automatic_profile_resetter.cc
@@ -85,16 +85,17 @@ const uint32 kCombinedStatusMaskMaximumValue =
 
 // Returns whether or not a dry-run shall be performed.
 bool ShouldPerformDryRun() {
-  return base::StartsWithASCII(
+  return base::StartsWith(
       base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName),
-      kAutomaticProfileResetStudyDryRunGroupName, true);
+      kAutomaticProfileResetStudyDryRunGroupName, base::CompareCase::SENSITIVE);
 }
 
 // Returns whether or not a live-run shall be performed.
 bool ShouldPerformLiveRun() {
-  return base::StartsWithASCII(
+  return base::StartsWith(
       base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName),
-      kAutomaticProfileResetStudyEnabledGroupName, true);
+      kAutomaticProfileResetStudyEnabledGroupName,
+      base::CompareCase::SENSITIVE);
 }
 
 // If the currently active experiment group prescribes a |program| and
diff --git a/chrome/browser/profiles/profile_io_data.cc b/chrome/browser/profiles/profile_io_data.cc
index 52c047b..0963814 100644
--- a/chrome/browser/profiles/profile_io_data.cc
+++ b/chrome/browser/profiles/profile_io_data.cc
@@ -161,7 +161,8 @@ bool IsSupportedDevToolsURL(const GURL& url, base::FilePath* path) {
 
   if (!url.SchemeIs(content::kChromeDevToolsScheme) ||
       url.host() != chrome::kChromeUIDevToolsHost ||
-      !base::StartsWithASCII(url.path(), bundled_path_prefix, false)) {
+      !base::StartsWith(url.path(), bundled_path_prefix,
+                        base::CompareCase::INSENSITIVE_ASCII)) {
     return false;
   }
 
diff --git a/chrome/browser/push_messaging/push_messaging_app_identifier.cc b/chrome/browser/push_messaging/push_messaging_app_identifier.cc
index 325081a..fa15b94 100644
--- a/chrome/browser/push_messaging/push_messaging_app_identifier.cc
+++ b/chrome/browser/push_messaging/push_messaging_app_identifier.cc
@@ -75,8 +75,8 @@ PushMessagingAppIdentifier PushMessagingAppIdentifier::Generate(
 // static
 PushMessagingAppIdentifier PushMessagingAppIdentifier::FindByAppId(
     Profile* profile, const std::string& app_id) {
-  if (!base::StartsWithASCII(app_id, kPushMessagingAppIdentifierPrefix,
-                             false /* case_sensitive */)) {
+  if (!base::StartsWith(app_id, kPushMessagingAppIdentifierPrefix,
+                        base::CompareCase::INSENSITIVE_ASCII)) {
     return PushMessagingAppIdentifier();
   }
 
diff --git a/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate_browsertest.cc b/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate_browsertest.cc
index 98e86d3..61829da 100644
--- a/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate_browsertest.cc
+++ b/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate_browsertest.cc
@@ -30,7 +30,8 @@ static const char kServerRedirectUrl[] = "/server-redirect";
 
 scoped_ptr<net::test_server::HttpResponse> HandleTestRequest(
     const net::test_server::HttpRequest& request) {
-  if (base::StartsWithASCII(request.relative_url, kServerRedirectUrl, true)) {
+  if (base::StartsWith(request.relative_url, kServerRedirectUrl,
+                       base::CompareCase::SENSITIVE)) {
     // Extract the target URL and redirect there.
     size_t query_string_pos = request.relative_url.find('?');
     std::string redirect_target =
diff --git a/chrome/browser/safe_browsing/protocol_manager.cc b/chrome/browser/safe_browsing/protocol_manager.cc
index 01aece1..8415327 100644
--- a/chrome/browser/safe_browsing/protocol_manager.cc
+++ b/chrome/browser/safe_browsing/protocol_manager.cc
@@ -749,10 +749,13 @@ GURL SafeBrowsingProtocolManager::GetHashUrl() const {
 GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
   DCHECK(CalledOnValidThread());
   std::string next_url;
-  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)) {
     // Use https if we updated via https, otherwise http (useful for testing).
-    if (base::StartsWithASCII(url_prefix_, "https://", false))
+    if (base::StartsWith(url_prefix_, "https://",
+                         base::CompareCase::INSENSITIVE_ASCII))
       next_url.append("https://");
     else
       next_url.append("http://");
diff --git a/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc b/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
index 0df6f8c..9378ec3 100644
--- a/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
@@ -1310,7 +1310,8 @@ class SafeBrowsingDatabaseManagerCookieTest : public InProcessBrowserTest {
  private:
   static scoped_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
-    if (!base::StartsWithASCII(request.relative_url, "/testpath/", true)) {
+    if (!base::StartsWith(request.relative_url, "/testpath/",
+                          base::CompareCase::SENSITIVE)) {
       ADD_FAILURE() << "bad path";
       return nullptr;
     }
diff --git a/chrome/browser/search/local_ntp_source.cc b/chrome/browser/search/local_ntp_source.cc
index 5d10b6f..90d9fe7 100644
--- a/chrome/browser/search/local_ntp_source.cc
+++ b/chrome/browser/search/local_ntp_source.cc
@@ -94,7 +94,7 @@ bool IsIconNTPEnabled() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableIconNtp))
     return true;
 
-  return base::StartsWithASCII(group_name, "Enabled", true);
+  return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
 }
 
 // Adds a localized string keyed by resource id to the dictionary.
diff --git a/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc b/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc
index 13f0967..2e60864 100644
--- a/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc
+++ b/chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc
@@ -50,7 +50,7 @@ GURL GetNormalizedURL(const GURL& url) {
   // Strip leading "www." (if any).
   const std::string www("www.");
   const std::string host(url.host());
-  if (base::StartsWithASCII(host, www, true))
+  if (base::StartsWith(host, www, base::CompareCase::SENSITIVE))
     replacements.SetHostStr(base::StringPiece(host).substr(www.size()));
   // Strip trailing slash (if any).
   const std::string path(url.path());
diff --git a/chrome/browser/supervised_user/supervised_user_settings_service.cc b/chrome/browser/supervised_user/supervised_user_settings_service.cc
index 80bf701b..40eb8ac 100644
--- a/chrome/browser/supervised_user/supervised_user_settings_service.cc
+++ b/chrome/browser/supervised_user/supervised_user_settings_service.cc
@@ -44,7 +44,8 @@ const char kSplitSettings[] = "split_settings";
 namespace {
 
 bool SettingShouldApplyToPrefs(const std::string& name) {
-  return !base::StartsWithASCII(name, kSupervisedUserInternalItemPrefix, false);
+  return !base::StartsWith(name, kSupervisedUserInternalItemPrefix,
+                           base::CompareCase::INSENSITIVE_ASCII);
 }
 
 }  // namespace
diff --git a/chrome/browser/supervised_user/supervised_user_settings_service_unittest.cc b/chrome/browser/supervised_user/supervised_user_settings_service_unittest.cc
index c2a99dc..aeca402 100644
--- a/chrome/browser/supervised_user/supervised_user_settings_service_unittest.cc
+++ b/chrome/browser/supervised_user/supervised_user_settings_service_unittest.cc
@@ -99,9 +99,9 @@ class SupervisedUserSettingsServiceTest : public ::testing::Test {
     if (supervised_user_setting.name() == kAtomicItemName) {
       expected_value = atomic_setting_value_.get();
     } else {
-      EXPECT_TRUE(base::StartsWithASCII(supervised_user_setting.name(),
-                                        std::string(kSplitItemName) + ':',
-                                        true));
+      EXPECT_TRUE(base::StartsWith(supervised_user_setting.name(),
+                                   std::string(kSplitItemName) + ':',
+                                   base::CompareCase::SENSITIVE));
       std::string key =
           supervised_user_setting.name().substr(strlen(kSplitItemName) + 1);
       EXPECT_TRUE(split_items_.GetWithoutPathExpansion(key, &expected_value));
diff --git a/chrome/browser/supervised_user/supervised_user_url_filter.cc b/chrome/browser/supervised_user/supervised_user_url_filter.cc
index ba513d9..b1dad56 100644
--- a/chrome/browser/supervised_user/supervised_user_url_filter.cc
+++ b/chrome/browser/supervised_user/supervised_user_url_filter.cc
@@ -250,7 +250,7 @@ bool SupervisedUserURLFilter::HostMatchesPattern(const std::string& host,
     trimmed_host.erase(trimmed_host.length() - (registry_length + 1));
   }
 
-  if (base::StartsWithASCII(trimmed_pattern, "*.", true)) {
+  if (base::StartsWith(trimmed_pattern, "*.", base::CompareCase::SENSITIVE)) {
     trimmed_pattern.erase(0, 2);
 
     // The remaining pattern should be non-empty, and it should not contain
diff --git a/chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc b/chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc
index e011d0d..e8240e9 100644
--- a/chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc
+++ b/chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc
@@ -1045,8 +1045,9 @@ TEST_F(SessionsSyncManagerTest, MergeWithLocalAndForeignTabs) {
   for (int i = 1; i < 3; i++) {
     EXPECT_TRUE(output[i].IsValid());
     const SyncData data(output[i].sync_data());
-    EXPECT_TRUE(base::StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
-                                      manager()->current_machine_tag(), true));
+    EXPECT_TRUE(base::StartsWith(syncer::SyncDataLocal(data).GetTag(),
+                                 manager()->current_machine_tag(),
+                                 base::CompareCase::SENSITIVE));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   }
@@ -1479,15 +1480,17 @@ TEST_F(SessionsSyncManagerTest, AssociateWindowsDontReloadTabs) {
   EXPECT_EQ(3U, out.size());  // Tab add, update, and header update.
 
   EXPECT_TRUE(
-      base::StartsWithASCII(syncer::SyncDataLocal(out[0].sync_data()).GetTag(),
-                            manager()->current_machine_tag(), true));
+      base::StartsWith(syncer::SyncDataLocal(out[0].sync_data()).GetTag(),
+                       manager()->current_machine_tag(),
+                       base::CompareCase::SENSITIVE));
   EXPECT_EQ(manager()->current_machine_tag(),
             out[0].sync_data().GetSpecifics().session().session_tag());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[0].change_type());
 
   EXPECT_TRUE(
-      base::StartsWithASCII(syncer::SyncDataLocal(out[1].sync_data()).GetTag(),
-                            manager()->current_machine_tag(), true));
+      base::StartsWith(syncer::SyncDataLocal(out[1].sync_data()).GetTag(),
+                       manager()->current_machine_tag(),
+                       base::CompareCase::SENSITIVE));
   EXPECT_EQ(manager()->current_machine_tag(),
             out[1].sync_data().GetSpecifics().session().session_tag());
   EXPECT_TRUE(out[1].sync_data().GetSpecifics().session().has_tab());
@@ -1541,8 +1544,9 @@ TEST_F(SessionsSyncManagerTest, OnLocalTabModified) {
     SCOPED_TRACE(i);
     EXPECT_TRUE(out[i].IsValid());
     const SyncData data(out[i].sync_data());
-    EXPECT_TRUE(base::StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
-                                      manager()->current_machine_tag(), true));
+    EXPECT_TRUE(base::StartsWith(syncer::SyncDataLocal(data).GetTag(),
+                                 manager()->current_machine_tag(),
+                                 base::CompareCase::SENSITIVE));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
     if (i % 6 == 0) {
@@ -1649,8 +1653,9 @@ TEST_F(SessionsSyncManagerTest, MergeLocalSessionExistingTabs) {
   for (int i = 1; i < 5; i++) {
     EXPECT_TRUE(out[i].IsValid());
     const SyncData data(out[i].sync_data());
-    EXPECT_TRUE(base::StartsWithASCII(syncer::SyncDataLocal(data).GetTag(),
-                                      manager()->current_machine_tag(), true));
+    EXPECT_TRUE(base::StartsWith(syncer::SyncDataLocal(data).GetTag(),
+                                 manager()->current_machine_tag(),
+                                 base::CompareCase::SENSITIVE));
     const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
     EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
     if (i % 2 == 1) {
diff --git a/chrome/browser/sync/test/integration/extensions_helper.cc b/chrome/browser/sync/test/integration/extensions_helper.cc
index 4448958..0be9509 100644
--- a/chrome/browser/sync/test/integration/extensions_helper.cc
+++ b/chrome/browser/sync/test/integration/extensions_helper.cc
@@ -124,7 +124,8 @@ std::string CreateFakeExtensionName(int index) {
 }
 
 bool ExtensionNameToIndex(const std::string& name, int* index) {
-  if (!base::StartsWithASCII(name, extension_name_prefix, true) ||
+  if (!base::StartsWith(name, extension_name_prefix,
+                        base::CompareCase::SENSITIVE) ||
       !base::StringToInt(name.substr(strlen(extension_name_prefix)), index)) {
     LOG(WARNING) << "Unable to convert extension name \"" << name
                  << "\" to index";
diff --git a/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc b/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
index b7624c8..6922bbd 100644
--- a/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
+++ b/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
@@ -144,7 +144,7 @@ SyncStatusCode DriveApiErrorCodeToSyncStatusCode(
 
 bool RemovePrefix(const std::string& str, const std::string& prefix,
                   std::string* out) {
-  if (!base::StartsWithASCII(str, prefix, true)) {
+  if (!base::StartsWith(str, prefix, base::CompareCase::SENSITIVE)) {
     if (out)
       *out = str;
     return false;
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
index b656450..22fc4ff 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
@@ -522,8 +522,8 @@ bool MetadataDatabaseIndexOnDisk::HasDemotedDirtyTracker() const {
   itr->Seek(kDemotedDirtyIDKeyPrefix);
   if (!itr->Valid())
     return false;
-  return base::StartsWithASCII(itr->key().ToString(), kDemotedDirtyIDKeyPrefix,
-                               true);
+  return base::StartsWith(itr->key().ToString(), kDemotedDirtyIDKeyPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 bool MetadataDatabaseIndexOnDisk::IsDemotedDirtyTracker(
@@ -571,8 +571,8 @@ size_t MetadataDatabaseIndexOnDisk::CountFileMetadata() const {
   size_t count = 0;
   scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileMetadataKeyPrefix); itr->Valid(); itr->Next()) {
-    if (!base::StartsWithASCII(itr->key().ToString(), kFileMetadataKeyPrefix,
-                               true))
+    if (!base::StartsWith(itr->key().ToString(), kFileMetadataKeyPrefix,
+                          base::CompareCase::SENSITIVE))
       break;
     ++count;
   }
@@ -584,8 +584,8 @@ size_t MetadataDatabaseIndexOnDisk::CountFileTracker() const {
   size_t count = 0;
   scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
-    if (!base::StartsWithASCII(itr->key().ToString(), kFileTrackerKeyPrefix,
-                               true))
+    if (!base::StartsWith(itr->key().ToString(), kFileTrackerKeyPrefix,
+                          base::CompareCase::SENSITIVE))
       break;
     ++count;
   }
@@ -1146,7 +1146,8 @@ size_t MetadataDatabaseIndexOnDisk::CountDirtyTrackerInternal() const {
 
   scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kDirtyIDKeyPrefix); itr->Valid(); itr->Next()) {
-    if (!base::StartsWithASCII(itr->key().ToString(), kDirtyIDKeyPrefix, true))
+    if (!base::StartsWith(itr->key().ToString(), kDirtyIDKeyPrefix,
+                          base::CompareCase::SENSITIVE))
       break;
     ++num_dirty_trackers;
   }
@@ -1181,7 +1182,7 @@ void MetadataDatabaseIndexOnDisk::DeleteKeyStartsWith(
   scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(prefix); itr->Valid();) {
     const std::string key = itr->key().ToString();
-    if (!base::StartsWithASCII(key, prefix, true))
+    if (!base::StartsWith(key, prefix, base::CompareCase::SENSITIVE))
       break;
     itr->Delete();
   }
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc b/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc
index deafbea3..df45a54 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc
@@ -46,24 +46,34 @@ SyncStatusCode MigrateDatabaseFromV4ToV3(leveldb::DB* db) {
     std::string key = itr->key().ToString();
 
     // Do nothing for valid entries in both versions.
-    if (base::StartsWithASCII(key, kServiceMetadataKey, true) ||
-        base::StartsWithASCII(key, kFileMetadataKeyPrefix, true) ||
-        base::StartsWithASCII(key, kFileTrackerKeyPrefix, true)) {
+    if (base::StartsWith(key, kServiceMetadataKey,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kFileMetadataKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kFileTrackerKeyPrefix,
+                         base::CompareCase::SENSITIVE)) {
       continue;
     }
 
     // Drop entries used in version 4 only.
-    if (base::StartsWithASCII(key, kAppRootIDByAppIDKeyPrefix, true) ||
-        base::StartsWithASCII(key, kActiveTrackerIDByFileIDKeyPrefix, true) ||
-        base::StartsWithASCII(key, kTrackerIDByFileIDKeyPrefix, true) ||
-        base::StartsWithASCII(key, kMultiTrackerByFileIDKeyPrefix, true) ||
-        base::StartsWithASCII(key, kActiveTrackerIDByParentAndTitleKeyPrefix,
-                              true) ||
-        base::StartsWithASCII(key, kTrackerIDByParentAndTitleKeyPrefix, true) ||
-        base::StartsWithASCII(key, kMultiBackingParentAndTitleKeyPrefix,
-                              true) ||
-        base::StartsWithASCII(key, kDirtyIDKeyPrefix, true) ||
-        base::StartsWithASCII(key, kDemotedDirtyIDKeyPrefix, true)) {
+    if (base::StartsWith(key, kAppRootIDByAppIDKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kActiveTrackerIDByFileIDKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kTrackerIDByFileIDKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kMultiTrackerByFileIDKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kActiveTrackerIDByParentAndTitleKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kTrackerIDByParentAndTitleKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kMultiBackingParentAndTitleKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kDirtyIDKeyPrefix,
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(key, kDemotedDirtyIDKeyPrefix,
+                         base::CompareCase::SENSITIVE)) {
       write_batch.Delete(key);
       continue;
     }
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util_unittest.cc b/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util_unittest.cc
index 2d9308c..89b84b4 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util_unittest.cc
@@ -40,7 +40,8 @@ void VerifyNotExist(const std::string& key, leveldb::DB* db) {
 
   itr->Seek(key);
   EXPECT_TRUE(!itr->Valid() ||
-              !base::StartsWithASCII(itr->key().ToString(), key, true));
+              !base::StartsWith(itr->key().ToString(), key,
+                                base::CompareCase::SENSITIVE));
 }
 
 }  // namespace
diff --git a/chrome/browser/ui/app_list/app_list_syncable_service.cc b/chrome/browser/ui/app_list/app_list_syncable_service.cc
index 5a44a21..7ab733b 100644
--- a/chrome/browser/ui/app_list/app_list_syncable_service.cc
+++ b/chrome/browser/ui/app_list/app_list_syncable_service.cc
@@ -142,7 +142,8 @@ bool GetAppListItemType(AppListItem* item,
 }
 
 bool IsDriveAppSyncId(const std::string& sync_id) {
-  return base::StartsWithASCII(sync_id, kDriveAppSyncIdPrefix, true);
+  return base::StartsWith(sync_id, kDriveAppSyncIdPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 std::string GetDriveAppSyncId(const std::string& drive_app_id) {
diff --git a/chrome/browser/ui/app_list/search/search_controller_factory.cc b/chrome/browser/ui/app_list/search/search_controller_factory.cc
index d2300ad..ed2dbf3 100644
--- a/chrome/browser/ui/app_list/search/search_controller_factory.cc
+++ b/chrome/browser/ui/app_list/search/search_controller_factory.cc
@@ -48,9 +48,10 @@ const char kSuggestionsProviderFieldTrialEnabledPrefix[] = "Enabled";
 // Returns whether the user is part of a group where the Suggestions provider is
 // enabled.
 bool IsSuggestionsSearchProviderEnabled() {
-  return base::StartsWithASCII(
+  return base::StartsWith(
       base::FieldTrialList::FindFullName(kSuggestionsProviderFieldTrialName),
-      kSuggestionsProviderFieldTrialEnabledPrefix, true);
+      kSuggestionsProviderFieldTrialEnabledPrefix,
+      base::CompareCase::SENSITIVE);
 }
 
 }  // namespace
diff --git a/chrome/browser/ui/browser_navigator_browsertest.cc b/chrome/browser/ui/browser_navigator_browsertest.cc
index 196b0d9..c9f88bb 100644
--- a/chrome/browser/ui/browser_navigator_browsertest.cc
+++ b/chrome/browser/ui/browser_navigator_browsertest.cc
@@ -1291,9 +1291,9 @@ IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
-  EXPECT_TRUE(base::StartsWithASCII(
+  EXPECT_TRUE(base::StartsWith(
       browser()->tab_strip_model()->GetActiveWebContents()->GetURL().spec(),
-      chrome::kChromeUIBookmarksURL, true));
+      chrome::kChromeUIBookmarksURL, base::CompareCase::SENSITIVE));
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
diff --git a/chrome/browser/ui/omnibox/omnibox_view.cc b/chrome/browser/ui/omnibox/omnibox_view.cc
index 02e3302..7c69614 100644
--- a/chrome/browser/ui/omnibox/omnibox_view.cc
+++ b/chrome/browser/ui/omnibox/omnibox_view.cc
@@ -28,7 +28,8 @@ base::string16 OmniboxView::StripJavascriptSchemas(const base::string16& text) {
   const base::string16 kJsPrefix(
       base::ASCIIToUTF16(url::kJavaScriptScheme) + base::ASCIIToUTF16(":"));
   base::string16 out(text);
-  while (base::StartsWith(out, kJsPrefix, false)) {
+  while (base::StartsWith(out, kJsPrefix,
+                          base::CompareCase::INSENSITIVE_ASCII)) {
     base::TrimWhitespace(out.substr(kJsPrefix.length()), base::TRIM_LEADING,
                          &out);
   }
diff --git a/chrome/browser/ui/prefs/prefs_tab_helper.cc b/chrome/browser/ui/prefs/prefs_tab_helper.cc
index 19c396d..e57c8a9 100644
--- a/chrome/browser/ui/prefs/prefs_tab_helper.cc
+++ b/chrome/browser/ui/prefs/prefs_tab_helper.cc
@@ -137,7 +137,8 @@ void RegisterFontFamilyMapObserver(
     PrefChangeRegistrar* registrar,
     const char* map_name,
     const PrefChangeRegistrar::NamedChangeCallback& obs) {
-  DCHECK(base::StartsWithASCII(map_name, "webkit.webprefs.", true));
+  DCHECK(base::StartsWith(map_name, "webkit.webprefs.",
+                          base::CompareCase::SENSITIVE));
 
   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
@@ -149,7 +150,8 @@ void RegisterFontFamilyMapObserver(
 // On Windows with antialising we want to use an alternate fixed font like
 // Consolas, which looks much better than Courier New.
 bool ShouldUseAlternateDefaultFixedFont(const std::string& script) {
-  if (!base::StartsWithASCII(script, "courier", false))
+  if (!base::StartsWith(script, "courier",
+                        base::CompareCase::INSENSITIVE_ASCII))
     return false;
   UINT smooth_type = 0;
   SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &smooth_type, 0);
diff --git a/chrome/browser/ui/search/instant_extended_manual_interactive_uitest.cc b/chrome/browser/ui/search/instant_extended_manual_interactive_uitest.cc
index e25c471..761dd95 100644
--- a/chrome/browser/ui/search/instant_extended_manual_interactive_uitest.cc
+++ b/chrome/browser/ui/search/instant_extended_manual_interactive_uitest.cc
@@ -58,8 +58,10 @@ class InstantExtendedManualTest : public InProcessBrowserTest,
   void SetUpOnMainThread() override {
     const testing::TestInfo* const test_info =
         testing::UnitTest::GetInstance()->current_test_info();
-    ASSERT_TRUE(base::StartsWithASCII(test_info->name(), "MANUAL_", true) ||
-                base::StartsWithASCII(test_info->name(), "DISABLED_", true));
+    ASSERT_TRUE(base::StartsWith(test_info->name(), "MANUAL_",
+                                 base::CompareCase::SENSITIVE) ||
+                base::StartsWith(test_info->name(), "DISABLED_",
+                                 base::CompareCase::SENSITIVE));
     // Make IsOffline() return false so we don't try to use the local NTP.
     disable_network_change_notifier_.reset(
         new net::NetworkChangeNotifier::DisableForTest());
diff --git a/chrome/browser/ui/webui/devtools_ui.cc b/chrome/browser/ui/webui/devtools_ui.cc
index 7a87620..7960c0f 100644
--- a/chrome/browser/ui/webui/devtools_ui.cc
+++ b/chrome/browser/ui/webui/devtools_ui.cc
@@ -143,7 +143,8 @@ void DevToolsDataSource::StartDataRequest(
   // Serve request from local bundle.
   std::string bundled_path_prefix(chrome::kChromeUIDevToolsBundledPath);
   bundled_path_prefix += "/";
-  if (base::StartsWithASCII(path, bundled_path_prefix, false)) {
+  if (base::StartsWith(path, bundled_path_prefix,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     StartBundledDataRequest(path.substr(bundled_path_prefix.length()),
                             render_process_id, render_frame_id, callback);
     return;
@@ -152,7 +153,8 @@ void DevToolsDataSource::StartDataRequest(
   // Serve request from remote location.
   std::string remote_path_prefix(chrome::kChromeUIDevToolsRemotePath);
   remote_path_prefix += "/";
-  if (base::StartsWithASCII(path, remote_path_prefix, false)) {
+  if (base::StartsWith(path, remote_path_prefix,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     StartRemoteDataRequest(path.substr(remote_path_prefix.length()),
                            render_process_id, render_frame_id, callback);
     return;
diff --git a/chrome/browser/ui/webui/extensions/chromeos/kiosk_apps_handler.cc b/chrome/browser/ui/webui/extensions/chromeos/kiosk_apps_handler.cc
index cd688e6..76a312b 100644
--- a/chrome/browser/ui/webui/extensions/chromeos/kiosk_apps_handler.cc
+++ b/chrome/browser/ui/webui/extensions/chromeos/kiosk_apps_handler.cc
@@ -75,8 +75,8 @@ bool ExtractsAppIdFromInput(const std::string& input,
 
   if (webstore_url.scheme() != webstore_base_url.scheme() ||
       webstore_url.host() != webstore_base_url.host() ||
-      !base::StartsWithASCII(webstore_url.path(), webstore_base_url.path(),
-                             true)) {
+      !base::StartsWith(webstore_url.path(), webstore_base_url.path(),
+                        base::CompareCase::SENSITIVE)) {
     return false;
   }
 
diff --git a/chrome/browser/ui/webui/interstitials/interstitial_ui.cc b/chrome/browser/ui/webui/interstitials/interstitial_ui.cc
index 23833b1..6c79b5a 100644
--- a/chrome/browser/ui/webui/interstitials/interstitial_ui.cc
+++ b/chrome/browser/ui/webui/interstitials/interstitial_ui.cc
@@ -182,9 +182,10 @@ void InterstitialHTMLSource::StartDataRequest(
     int render_frame_id,
     const content::URLDataSource::GotDataCallback& callback) {
   scoped_ptr<content::InterstitialPageDelegate> interstitial_delegate;
-  if (base::StartsWithASCII(path, "ssl", true)) {
+  if (base::StartsWith(path, "ssl", base::CompareCase::SENSITIVE)) {
     interstitial_delegate.reset(CreateSSLBlockingPage(web_contents_));
-  } else if (base::StartsWithASCII(path, "safebrowsing", true)) {
+  } else if (base::StartsWith(path, "safebrowsing",
+                              base::CompareCase::SENSITIVE)) {
     interstitial_delegate.reset(CreateSafeBrowsingBlockingPage(web_contents_));
   }
 
diff --git a/chrome/browser/ui/webui/media_router/media_router_ui.cc b/chrome/browser/ui/webui/media_router/media_router_ui.cc
index 5be8017..658a368 100644
--- a/chrome/browser/ui/webui/media_router/media_router_ui.cc
+++ b/chrome/browser/ui/webui/media_router/media_router_ui.cc
@@ -39,7 +39,7 @@ std::string GetHostFromURL(const GURL& gurl) {
   if (gurl.is_empty())
     return std::string();
   std::string host = gurl.host();
-  if (base::StartsWithASCII(host, "www.", false))
+  if (base::StartsWith(host, "www.", base::CompareCase::INSENSITIVE_ASCII))
     host = host.substr(4);
   return host;
 }
diff --git a/chrome/browser/ui/webui/ntp/favicon_webui_handler.cc b/chrome/browser/ui/webui/ntp/favicon_webui_handler.cc
index dcb600d..27e71a4 100644
--- a/chrome/browser/ui/webui/ntp/favicon_webui_handler.cc
+++ b/chrome/browser/ui/webui/ntp/favicon_webui_handler.cc
@@ -84,7 +84,8 @@ void FaviconWebUIHandler::HandleGetFaviconDominantColor(
   std::string path;
   CHECK(args->GetString(0, &path));
   std::string prefix = "chrome://favicon/size/";
-  DCHECK(base::StartsWithASCII(path, prefix, false)) << "path is " << path;
+  DCHECK(base::StartsWith(path, prefix, base::CompareCase::INSENSITIVE_ASCII))
+      << "path is " << path;
   size_t slash = path.find("/", prefix.length());
   path = path.substr(slash + 1);
 
diff --git a/chrome/browser/web_applications/web_app_mac.mm b/chrome/browser/web_applications/web_app_mac.mm
index d6f47a6..89cad0e 100644
--- a/chrome/browser/web_applications/web_app_mac.mm
+++ b/chrome/browser/web_applications/web_app_mac.mm
@@ -212,10 +212,10 @@ bool HasSameUserDataDir(const base::FilePath& bundle_path) {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   DCHECK(!user_data_dir.empty());
-  return base::StartsWithASCII(
+  return base::StartsWith(
       base::SysNSStringToUTF8(
           [plist valueForKey:app_mode::kCrAppModeUserDataDirKey]),
-      user_data_dir.value(), true /* case_sensitive */);
+      user_data_dir.value(), base::CompareCase::SENSITIVE);
 }
 
 void LaunchShimOnFileThread(scoped_ptr<web_app::ShortcutInfo> shortcut_info,
@@ -453,7 +453,8 @@ void DeletePathAndParentIfEmpty(const base::FilePath& app_path) {
 
 bool IsShimForProfile(const base::FilePath& base_name,
                       const std::string& profile_base_name) {
-  if (!base::StartsWithASCII(base_name.value(), profile_base_name, true))
+  if (!base::StartsWith(base_name.value(), profile_base_name,
+                        base::CompareCase::SENSITIVE))
     return false;
 
   if (base_name.Extension() != ".app")
diff --git a/chrome/common/crash_keys.cc b/chrome/common/crash_keys.cc
index d925cf9..0d53d77 100644
--- a/chrome/common/crash_keys.cc
+++ b/chrome/common/crash_keys.cc
@@ -344,11 +344,11 @@ static bool IsBoringSwitch(const std::string& flag) {
 
 #if defined(OS_WIN)
   // Just about everything has this, don't bother.
-  if (base::StartsWithASCII(flag, "/prefetch:", true))
+  if (base::StartsWith(flag, "/prefetch:", base::CompareCase::SENSITIVE))
     return true;
 #endif
 
-  if (!base::StartsWithASCII(flag, "--", true))
+  if (!base::StartsWith(flag, "--", base::CompareCase::SENSITIVE))
     return false;
   size_t end = flag.find("=");
   size_t len = (end == std::string::npos) ? flag.length() - 2 : end - 2;
diff --git a/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc b/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
index c2a4e7b..9ec60f0 100644
--- a/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
+++ b/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
@@ -200,8 +200,8 @@ FileBrowserHandler* LoadFileBrowserHandler(
         return NULL;
       }
       base::StringToLowerASCII(&filter);
-      if (!base::StartsWithASCII(
-              filter, std::string(url::kFileSystemScheme) + ':', true)) {
+      if (!base::StartsWith(filter, std::string(url::kFileSystemScheme) + ':',
+                            base::CompareCase::SENSITIVE)) {
         *error = extensions::ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, filter);
         return NULL;
diff --git a/chrome/common/extensions/chrome_extensions_client.cc b/chrome/common/extensions/chrome_extensions_client.cc
index 73f89c5..737b49a 100644
--- a/chrome/common/extensions/chrome_extensions_client.cc
+++ b/chrome/common/extensions/chrome_extensions_client.cc
@@ -367,10 +367,10 @@ bool ChromeExtensionsClient::IsBlacklistUpdateURL(const GURL& url) const {
   // ExtensionUpdater ensures that we notice a change. This is the full URL
   // of a blacklist:
   // http://www.gstatic.com/chrome/extensions/blacklist/l_0_0_0_7.txt
-  return base::StartsWithASCII(url.spec(), kExtensionBlocklistUrlPrefix,
-                               true) ||
-         base::StartsWithASCII(url.spec(), kExtensionBlocklistHttpsUrlPrefix,
-                               true);
+  return base::StartsWith(url.spec(), kExtensionBlocklistUrlPrefix,
+                          base::CompareCase::SENSITIVE) ||
+         base::StartsWith(url.spec(), kExtensionBlocklistHttpsUrlPrefix,
+                          base::CompareCase::SENSITIVE);
 }
 
 std::set<base::FilePath> ChromeExtensionsClient::GetBrowserImagePaths(
diff --git a/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc b/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
index cb86156..5b9c843 100644
--- a/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
@@ -103,7 +103,7 @@ scoped_ptr<ChromeSettingsOverrides::Search_provider> ParseSearchEngine(
 // A www. prefix is not informative and thus not worth the limited real estate
 // in the permissions UI.
 std::string RemoveWwwPrefix(const std::string& url) {
-  if (base::StartsWithASCII(url, kWwwPrefix, false))
+  if (base::StartsWith(url, kWwwPrefix, base::CompareCase::INSENSITIVE_ASCII))
     return url.substr(strlen(kWwwPrefix));
   return url;
 }
diff --git a/chrome/common/extensions/manifest_tests/extension_manifests_homepage_unittest.cc b/chrome/common/extensions/manifest_tests/extension_manifests_homepage_unittest.cc
index 5ba9582..c066adc 100644
--- a/chrome/common/extensions/manifest_tests/extension_manifests_homepage_unittest.cc
+++ b/chrome/common/extensions/manifest_tests/extension_manifests_homepage_unittest.cc
@@ -39,9 +39,10 @@ TEST_F(HomepageURLManifestTest, GetHomepageURL) {
   // The Google Gallery URL ends with the id, which depends on the path, which
   // can be different in testing, so we just check the part before id.
   extension = LoadAndExpectSuccess("homepage_google_hosted.json");
-  EXPECT_TRUE(base::StartsWithASCII(
+  EXPECT_TRUE(base::StartsWith(
       extensions::ManifestURL::GetHomepageURL(extension.get()).spec(),
-      "https://chrome.google.com/webstore/detail/", false));
+      "https://chrome.google.com/webstore/detail/",
+      base::CompareCase::INSENSITIVE_ASCII));
 
   extension = LoadAndExpectSuccess("homepage_externally_hosted.json");
   EXPECT_EQ(GURL(), extensions::ManifestURL::GetHomepageURL(extension.get()));
diff --git a/chrome/common/pref_names_util.cc b/chrome/common/pref_names_util.cc
index 0857265..70efc1b 100644
--- a/chrome/common/pref_names_util.cc
+++ b/chrome/common/pref_names_util.cc
@@ -13,7 +13,8 @@ const char kWebKitFontPrefPrefix[] = "webkit.webprefs.fonts.";
 bool ParseFontNamePrefPath(const std::string& pref_path,
                            std::string* generic_family,
                            std::string* script) {
-  if (!base::StartsWithASCII(pref_path, kWebKitFontPrefPrefix, true))
+  if (!base::StartsWith(pref_path, kWebKitFontPrefPrefix,
+                        base::CompareCase::SENSITIVE))
     return false;
 
   size_t start = strlen(kWebKitFontPrefPrefix);
diff --git a/chrome/renderer/chrome_content_renderer_client.cc b/chrome/renderer/chrome_content_renderer_client.cc
index f8779f4..03325bb 100644
--- a/chrome/renderer/chrome_content_renderer_client.cc
+++ b/chrome/renderer/chrome_content_renderer_client.cc
@@ -1481,10 +1481,14 @@ bool ChromeContentRendererClient::AllowPepperMediaStreamAPI(
   // these APIs are public and stable.
   std::string url_host = url.host();
   if (url.SchemeIs("https") &&
-      (base::EndsWith(url_host, "talkgadget.google.com", false) ||
-       base::EndsWith(url_host, "plus.google.com", false) ||
-       base::EndsWith(url_host, "plus.sandbox.google.com", false)) &&
-      base::StartsWithASCII(url.path(), "/hangouts/", false)) {
+      (base::EndsWith(url_host, "talkgadget.google.com",
+                      base::CompareCase::INSENSITIVE_ASCII) ||
+       base::EndsWith(url_host, "plus.google.com",
+                      base::CompareCase::INSENSITIVE_ASCII) ||
+       base::EndsWith(url_host, "plus.sandbox.google.com",
+                      base::CompareCase::INSENSITIVE_ASCII)) &&
+      base::StartsWith(url.path(), "/hangouts/",
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     return true;
   }
   // Allow access for tests.
diff --git a/chrome/renderer/content_settings_observer.cc b/chrome/renderer/content_settings_observer.cc
index 94654b2..7204e93 100644
--- a/chrome/renderer/content_settings_observer.cc
+++ b/chrome/renderer/content_settings_observer.cc
@@ -107,7 +107,7 @@ static const char kDotHTML[] = ".html";
 static const char kGoogleDotCom[] = "google.com";
 
 static bool IsHostInDomain(const std::string& host, const std::string& domain) {
-  return (base::EndsWith(host, domain, false) &&
+  return (base::EndsWith(host, domain, base::CompareCase::INSENSITIVE_ASCII) &&
           (host.length() == domain.length() ||
            (host.length() > domain.length() &&
             host[host.length() - domain.length() - 1] == '.')));
@@ -474,19 +474,19 @@ bool ContentSettingsObserver::allowDisplayingInsecureContent(
   GURL frame_gurl(frame->document().url());
   if (IsHostInDomain(origin_host, kGoogleDotCom)) {
     SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE);
-    if (base::StartsWithASCII(frame_gurl.path(), kGoogleSupportPathPrefix,
-                              false)) {
+    if (base::StartsWith(frame_gurl.path(), kGoogleSupportPathPrefix,
+                         base::CompareCase::INSENSITIVE_ASCII)) {
       SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE_SUPPORT);
-    } else if (base::StartsWithASCII(frame_gurl.path(), kGoogleIntlPathPrefix,
-                                     false)) {
+    } else if (base::StartsWith(frame_gurl.path(), kGoogleIntlPathPrefix,
+                                base::CompareCase::INSENSITIVE_ASCII)) {
       SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE_INTL);
     }
   }
 
   if (origin_host == kWWWDotGoogleDotCom) {
     SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_WWW_GOOGLE);
-    if (base::StartsWithASCII(frame_gurl.path(), kGoogleReaderPathPrefix,
-                              false))
+    if (base::StartsWith(frame_gurl.path(), kGoogleReaderPathPrefix,
+                         base::CompareCase::INSENSITIVE_ASCII))
       SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE_READER);
   } else if (origin_host == kMailDotGoogleDotCom) {
     SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_MAIL_GOOGLE);
@@ -509,7 +509,8 @@ bool ContentSettingsObserver::allowDisplayingInsecureContent(
   }
 
   GURL resource_gurl(resource_url);
-  if (base::EndsWith(resource_gurl.path(), kDotHTML, false))
+  if (base::EndsWith(resource_gurl.path(), kDotHTML,
+                     base::CompareCase::INSENSITIVE_ASCII))
     SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HTML);
 
   if (allowed_per_settings || allow_displaying_insecure_content_)
@@ -532,19 +533,19 @@ bool ContentSettingsObserver::allowRunningInsecureContent(
   bool is_google = IsHostInDomain(origin_host, kGoogleDotCom);
   if (is_google) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE);
-    if (base::StartsWithASCII(frame_gurl.path(), kGoogleSupportPathPrefix,
-                              false)) {
+    if (base::StartsWith(frame_gurl.path(), kGoogleSupportPathPrefix,
+                         base::CompareCase::INSENSITIVE_ASCII)) {
       SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE_SUPPORT);
-    } else if (base::StartsWithASCII(frame_gurl.path(), kGoogleIntlPathPrefix,
-                                     false)) {
+    } else if (base::StartsWith(frame_gurl.path(), kGoogleIntlPathPrefix,
+                                base::CompareCase::INSENSITIVE_ASCII)) {
       SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE_INTL);
     }
   }
 
   if (origin_host == kWWWDotGoogleDotCom) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_WWW_GOOGLE);
-    if (base::StartsWithASCII(frame_gurl.path(), kGoogleReaderPathPrefix,
-                              false))
+    if (base::StartsWith(frame_gurl.path(), kGoogleReaderPathPrefix,
+                         base::CompareCase::INSENSITIVE_ASCII))
       SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE_READER);
   } else if (origin_host == kMailDotGoogleDotCom) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_MAIL_GOOGLE);
@@ -564,7 +565,8 @@ bool ContentSettingsObserver::allowRunningInsecureContent(
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_MAPS_GOOGLE);
   } else if (origin_host == kWWWDotYoutubeDotCom) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_YOUTUBE);
-  } else if (base::EndsWith(origin_host, kDotGoogleUserContentDotCom, false)) {
+  } else if (base::EndsWith(origin_host, kDotGoogleUserContentDotCom,
+                            base::CompareCase::INSENSITIVE_ASCII)) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLEUSERCONTENT);
   }
 
@@ -572,11 +574,14 @@ bool ContentSettingsObserver::allowRunningInsecureContent(
   if (resource_gurl.host() == kWWWDotYoutubeDotCom)
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_TARGET_YOUTUBE);
 
-  if (base::EndsWith(resource_gurl.path(), kDotJS, false))
+  if (base::EndsWith(resource_gurl.path(), kDotJS,
+                     base::CompareCase::INSENSITIVE_ASCII))
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_JS);
-  else if (base::EndsWith(resource_gurl.path(), kDotCSS, false))
+  else if (base::EndsWith(resource_gurl.path(), kDotCSS,
+                          base::CompareCase::INSENSITIVE_ASCII))
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_CSS);
-  else if (base::EndsWith(resource_gurl.path(), kDotSWF, false))
+  else if (base::EndsWith(resource_gurl.path(), kDotSWF,
+                          base::CompareCase::INSENSITIVE_ASCII))
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_SWF);
 
   if (!allow_running_insecure_content_ && !allowed_per_settings) {
diff --git a/chrome/renderer/extensions/app_bindings.cc b/chrome/renderer/extensions/app_bindings.cc
index 7ead4ef..34997d0 100644
--- a/chrome/renderer/extensions/app_bindings.cc
+++ b/chrome/renderer/extensions/app_bindings.cc
@@ -39,7 +39,8 @@ bool IsCheckoutURL(const std::string& url_spec) {
   if (checkout_url_prefix.empty())
     checkout_url_prefix = "https://checkout.google.com/";
 
-  return base::StartsWithASCII(url_spec, checkout_url_prefix, false);
+  return base::StartsWith(url_spec, checkout_url_prefix,
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 bool CheckAccessToAppDetails(WebFrame* frame, v8::Isolate* isolate) {
diff --git a/chrome/renderer/extensions/extension_localization_peer.cc b/chrome/renderer/extensions/extension_localization_peer.cc
index 17b9756..bb0adb7 100644
--- a/chrome/renderer/extensions/extension_localization_peer.cc
+++ b/chrome/renderer/extensions/extension_localization_peer.cc
@@ -55,7 +55,8 @@ ExtensionLocalizationPeer::CreateExtensionLocalizationPeer(
   // Return NULL if content is not text/css or it doesn't belong to extension
   // scheme.
   return (request_url.SchemeIs(extensions::kExtensionScheme) &&
-          base::StartsWithASCII(mime_type, "text/css", false))
+          base::StartsWith(mime_type, "text/css",
+                           base::CompareCase::INSENSITIVE_ASCII))
              ? new ExtensionLocalizationPeer(peer, message_sender, request_url)
              : NULL;
 }
diff --git a/chrome/renderer/extensions/webstore_bindings.cc b/chrome/renderer/extensions/webstore_bindings.cc
index a7b4b1c..ab4c66e 100644
--- a/chrome/renderer/extensions/webstore_bindings.cc
+++ b/chrome/renderer/extensions/webstore_bindings.cc
@@ -160,8 +160,8 @@ bool WebstoreBindings::GetWebstoreItemIdFromFrame(
 
     if (webstore_url.scheme() != webstore_base_url.scheme() ||
         webstore_url.host() != webstore_base_url.host() ||
-        !base::StartsWithASCII(webstore_url.path(), webstore_base_url.path(),
-                               true)) {
+        !base::StartsWith(webstore_url.path(), webstore_base_url.path(),
+                          base::CompareCase::SENSITIVE)) {
       *error = kInvalidWebstoreItemUrlError;
       return false;
     }
diff --git a/chrome/renderer/page_load_histograms.cc b/chrome/renderer/page_load_histograms.cc
index c878368..97f7c38 100644
--- a/chrome/renderer/page_load_histograms.cc
+++ b/chrome/renderer/page_load_histograms.cc
@@ -179,16 +179,21 @@ bool ViaHeaderContains(WebFrame* frame, const std::string& via_value) {
 // purposes.
 // TODO(pmeenan): Remove the fuzzy logic when the referrer is reliable
 bool IsFromGoogleSearchResult(const GURL& url, const GURL& referrer) {
-  if (!base::StartsWithASCII(referrer.host(), "www.google.", true))
+  if (!base::StartsWith(referrer.host(), "www.google.",
+                        base::CompareCase::SENSITIVE))
     return false;
-  if (base::StartsWithASCII(referrer.path(), "/url", true))
+  if (base::StartsWith(referrer.path(), "/url",
+                       base::CompareCase::SENSITIVE))
     return true;
   bool is_possible_search_referrer =
       referrer.path().empty() || referrer.path() == "/" ||
-      base::StartsWithASCII(referrer.path(), "/search", true) ||
-      base::StartsWithASCII(referrer.path(), "/webhp", true);
+      base::StartsWith(referrer.path(), "/search",
+                       base::CompareCase::SENSITIVE) ||
+      base::StartsWith(referrer.path(), "/webhp",
+                       base::CompareCase::SENSITIVE);
   if (is_possible_search_referrer &&
-      !base::StartsWithASCII(url.host(), "www.google", true))
+      !base::StartsWith(url.host(), "www.google",
+                        base::CompareCase::SENSITIVE))
     return true;
   return false;
 }
diff --git a/chrome/renderer/searchbox/searchbox_extension.cc b/chrome/renderer/searchbox/searchbox_extension.cc
index 277e5a1..17e7bf1 100644
--- a/chrome/renderer/searchbox/searchbox_extension.cc
+++ b/chrome/renderer/searchbox/searchbox_extension.cc
@@ -76,7 +76,7 @@ bool IsIconNTPEnabled() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableIconNtp))
     return true;
 
-  return base::StartsWithASCII(group_name, "Enabled", true);
+  return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
 }
 
 // Converts string16 to V8 String.
diff --git a/chrome/service/cloud_print/cloud_print_connector.cc b/chrome/service/cloud_print/cloud_print_connector.cc
index 89d06b2..a1f6be7 100644
--- a/chrome/service/cloud_print/cloud_print_connector.cc
+++ b/chrome/service/cloud_print/cloud_print_connector.cc
@@ -418,8 +418,8 @@ void CloudPrintConnector::InitJobHandlerForPrinter(
     for (size_t index = 0; index < tags_list->GetSize(); index++) {
       std::string tag;
       if (tags_list->GetString(index, &tag) &&
-          base::StartsWithASCII(tag, kCloudPrintServiceTagsHashTagName,
-                                false)) {
+          base::StartsWith(tag, kCloudPrintServiceTagsHashTagName,
+                           base::CompareCase::INSENSITIVE_ASCII)) {
         std::vector<std::string> tag_parts;
         base::SplitStringDontTrim(tag, '=', &tag_parts);
         DCHECK_EQ(tag_parts.size(), 2U);
diff --git a/chrome/test/chromedriver/chrome/web_view_impl.cc b/chrome/test/chromedriver/chrome/web_view_impl.cc
index c1ec10e..c87f139 100644
--- a/chrome/test/chromedriver/chrome/web_view_impl.cc
+++ b/chrome/test/chromedriver/chrome/web_view_impl.cc
@@ -155,7 +155,8 @@ Status WebViewImpl::HandleReceivedEvents() {
 Status WebViewImpl::Load(const std::string& url) {
   // Javascript URLs will cause a hang while waiting for the page to stop
   // loading, so just disallow.
-  if (base::StartsWithASCII(url, "javascript:", false))
+  if (base::StartsWith(url, "javascript:",
+                       base::CompareCase::INSENSITIVE_ASCII))
     return Status(kUnknownError, "unsupported protocol");
   base::DictionaryValue params;
   params.SetString("url", url);
diff --git a/chrome/test/chromedriver/performance_logger.cc b/chrome/test/chromedriver/performance_logger.cc
index 2dceef9..37e66f4 100644
--- a/chrome/test/chromedriver/performance_logger.cc
+++ b/chrome/test/chromedriver/performance_logger.cc
@@ -52,8 +52,8 @@ bool ShouldRequestTraceEvents(const std::string& command) {
 // Returns whether the event belongs to one of kDomains.
 bool ShouldLogEvent(const std::string& method) {
   for (size_t i_domain = 0; i_domain < arraysize(kDomains); ++i_domain) {
-    if (base::StartsWithASCII(method, kDomains[i_domain],
-                              true /* case_sensitive */))
+    if (base::StartsWith(method, kDomains[i_domain],
+                         base::CompareCase::SENSITIVE))
       return true;
   }
   return false;
diff --git a/chrome/test/chromedriver/server/http_handler.cc b/chrome/test/chromedriver/server/http_handler.cc
index 77bed02..0d54c22 100644
--- a/chrome/test/chromedriver/server/http_handler.cc
+++ b/chrome/test/chromedriver/server/http_handler.cc
@@ -580,7 +580,7 @@ void HttpHandler::Handle(const net::HttpServerRequestInfo& request,
     return;
 
   std::string path = request.path;
-  if (!base::StartsWithASCII(path, url_base_, true)) {
+  if (!base::StartsWith(path, url_base_, base::CompareCase::SENSITIVE)) {
     scoped_ptr<net::HttpServerResponseInfo> response(
         new net::HttpServerResponseInfo(net::HTTP_BAD_REQUEST));
     response->SetBody("unhandled request", "text/plain");
diff --git a/chrome/utility/importer/bookmark_html_reader.cc b/chrome/utility/importer/bookmark_html_reader.cc
index 0fa2c92..1350512 100644
--- a/chrome/utility/importer/bookmark_html_reader.cc
+++ b/chrome/utility/importer/bookmark_html_reader.cc
@@ -119,7 +119,8 @@ void ImportBookmarksFile(
     // multiple "<HR>" tags at the beginning of a single line.
     // See http://crbug.com/257474.
     static const char kHrTag[] = "<HR>";
-    while (base::StartsWithASCII(line, kHrTag, false)) {
+    while (base::StartsWith(line, kHrTag,
+                            base::CompareCase::INSENSITIVE_ASCII)) {
       line.erase(0, arraysize(kHrTag) - 1);
       base::TrimString(line, " ", &line);
     }
@@ -205,7 +206,7 @@ void ImportBookmarksFile(
     }
 
     // Bookmarks in sub-folder are encapsulated with <DL> tag.
-    if (base::StartsWithASCII(line, "<DL>", false)) {
+    if (base::StartsWith(line, "<DL>", base::CompareCase::INSENSITIVE_ASCII)) {
       has_subfolder = true;
       if (!last_folder.empty()) {
         path.push_back(last_folder);
@@ -216,7 +217,8 @@ void ImportBookmarksFile(
 
       // Mark next folder empty as initial state.
       last_folder_is_empty = true;
-    } else if (base::StartsWithASCII(line, "</DL>", false)) {
+    } else if (base::StartsWith(line, "</DL>",
+                                base::CompareCase::INSENSITIVE_ASCII)) {
       if (path.empty())
         break;  // Mismatch <DL>.
 
@@ -278,7 +280,7 @@ namespace internal {
 
 bool ParseCharsetFromLine(const std::string& line, std::string* charset) {
   const char kCharset[] = "charset=";
-  if (base::StartsWithASCII(line, "<META", false) &&
+  if (base::StartsWith(line, "<META", base::CompareCase::INSENSITIVE_ASCII) &&
       (line.find("CONTENT=\"") != std::string::npos ||
        line.find("content=\"") != std::string::npos)) {
     size_t begin = line.find(kCharset);
@@ -302,7 +304,7 @@ bool ParseFolderNameFromLine(const std::string& line,
   const char kToolbarFolderAttribute[] = "PERSONAL_TOOLBAR_FOLDER";
   const char kAddDateAttribute[] = "ADD_DATE";
 
-  if (!base::StartsWithASCII(line, kFolderOpen, true))
+  if (!base::StartsWith(line, kFolderOpen, base::CompareCase::SENSITIVE))
     return false;
 
   size_t end = line.find(kFolderClose);
@@ -361,7 +363,7 @@ bool ParseBookmarkFromLine(const std::string& line,
   post_data->clear();
   *add_date = base::Time();
 
-  if (!base::StartsWithASCII(line, kItemOpen, true))
+  if (!base::StartsWith(line, kItemOpen, base::CompareCase::SENSITIVE))
     return false;
 
   size_t end = line.find(kItemClose);
@@ -437,7 +439,7 @@ bool ParseMinimumBookmarkFromLine(const std::string& line,
   *url = GURL();
 
   // Case-insensitive check of open tag.
-  if (!base::StartsWithASCII(line, kItemOpen, false))
+  if (!base::StartsWith(line, kItemOpen, base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
   // Find any close tag.
diff --git a/chrome/utility/media_galleries/media_metadata_parser.cc b/chrome/utility/media_galleries/media_metadata_parser.cc
index a39324e..b1fb81c 100644
--- a/chrome/utility/media_galleries/media_metadata_parser.cc
+++ b/chrome/utility/media_galleries/media_metadata_parser.cc
@@ -166,8 +166,8 @@ MediaMetadataParser::MediaMetadataParser(media::DataSource* source,
 MediaMetadataParser::~MediaMetadataParser() {}
 
 void MediaMetadataParser::Start(const MetadataCallback& callback) {
-  if (base::StartsWithASCII(mime_type_, "audio/", true) ||
-      base::StartsWithASCII(mime_type_, "video/", true)) {
+  if (base::StartsWith(mime_type_, "audio/", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(mime_type_, "video/", base::CompareCase::SENSITIVE)) {
     MediaMetadata* metadata = new MediaMetadata;
     metadata->mime_type = mime_type_;
     std::vector<AttachedImage>* attached_images =
@@ -183,7 +183,7 @@ void MediaMetadataParser::Start(const MetadataCallback& callback) {
     return;
   }
 
-  if (base::StartsWithASCII(mime_type_, "image/", true)) {
+  if (base::StartsWith(mime_type_, "image/", base::CompareCase::SENSITIVE)) {
     ImageMetadataExtractor* extractor = new ImageMetadataExtractor;
     extractor->Extract(
         source_,
diff --git a/chrome/utility/media_galleries/picasa_album_table_reader.cc b/chrome/utility/media_galleries/picasa_album_table_reader.cc
index 94b4aa5..2deba4e 100644
--- a/chrome/utility/media_galleries/picasa_album_table_reader.cc
+++ b/chrome/utility/media_galleries/picasa_album_table_reader.cc
@@ -91,7 +91,8 @@ bool PicasaAlbumTableReader::Init() {
     if (category == kAlbumCategoryAlbum) {
       std::string token;
       if (!token_column.ReadString(i, &token) || token.empty() ||
-          !base::StartsWithASCII(token, kAlbumTokenPrefix, false)) {
+          !base::StartsWith(token, kAlbumTokenPrefix,
+                            base::CompareCase::INSENSITIVE_ASCII)) {
         continue;
       }
 
diff --git a/components/omnibox/builtin_provider.cc b/components/omnibox/builtin_provider.cc
index 9d0a008..a364847 100644
--- a/components/omnibox/builtin_provider.cc
+++ b/components/omnibox/builtin_provider.cc
@@ -42,9 +42,11 @@ void BuiltinProvider::Start(const AutocompleteInput& input,
   const int kUrl = ACMatchClassification::URL;
   const int kMatch = kUrl | ACMatchClassification::MATCH;
 
-  base::string16 text = input.text();
-  bool starting_about = base::StartsWith(embedderAbout, text, false);
-  if (starting_about || base::StartsWith(kAbout, text, false)) {
+  const base::string16 text = input.text();
+  bool starting_about = base::StartsWith(embedderAbout, text,
+                                         base::CompareCase::INSENSITIVE_ASCII);
+  if (starting_about ||
+      base::StartsWith(kAbout, text, base::CompareCase::INSENSITIVE_ASCII)) {
     ACMatchClassifications styles;
     // Highlight the input portion matching |embedderAbout|; or if the user has
     // input "about:" (with optional slashes), highlight the whole
@@ -70,10 +72,12 @@ void BuiltinProvider::Start(const AutocompleteInput& input,
       const base::string16 blank_host = base::ASCIIToUTF16("blank");
       const base::string16 host = base::UTF8ToUTF16(url.host());
       if (base::StartsWith(text, base::ASCIIToUTF16(url::kAboutScheme),
-                           false) &&
-          base::StartsWith(blank_host, host, false) &&
+                           base::CompareCase::INSENSITIVE_ASCII) &&
+          base::StartsWith(blank_host, host,
+                           base::CompareCase::INSENSITIVE_ASCII) &&
           (url.path().length() <= 1) &&
-          !base::EndsWith(text, base::ASCIIToUTF16("/"), false)) {
+          !base::EndsWith(text, base::ASCIIToUTF16("/"),
+                          base::CompareCase::SENSITIVE)) {
         ACMatchClassifications styles;
         styles.push_back(ACMatchClassification(0, kMatch));
         base::string16 match = base::ASCIIToUTF16(url::kAboutBlankURL);
@@ -90,7 +94,8 @@ void BuiltinProvider::Start(const AutocompleteInput& input,
       size_t match_length = embedderAbout.length() + host_and_path.length();
       for (Builtins::const_iterator i(builtins_.begin());
           (i != builtins_.end()) && (matches_.size() < kMaxMatches); ++i) {
-        if (base::StartsWith(*i, host_and_path, false)) {
+        if (base::StartsWith(*i, host_and_path,
+                             base::CompareCase::INSENSITIVE_ASCII)) {
           ACMatchClassifications styles;
           // Highlight |embedderAbout|, even for input "about:foo".
           styles.push_back(ACMatchClassification(0, kMatch));
diff --git a/components/omnibox/shortcuts_backend.cc b/components/omnibox/shortcuts_backend.cc
index 945639b..a28b0cb 100644
--- a/components/omnibox/shortcuts_backend.cc
+++ b/components/omnibox/shortcuts_backend.cc
@@ -119,7 +119,8 @@ void ShortcutsBackend::AddOrUpdateShortcut(const base::string16& text,
   for (ShortcutMap::const_iterator it(
            shortcuts_map_.lower_bound(text_lowercase));
        it != shortcuts_map_.end() &&
-           base::StartsWith(it->first, text_lowercase, true);
+           base::StartsWith(it->first, text_lowercase,
+                            base::CompareCase::SENSITIVE);
        ++it) {
     if (match.destination_url == it->second.match_core.destination_url) {
       UpdateShortcut(ShortcutsDatabase::Shortcut(
@@ -286,9 +287,9 @@ bool ShortcutsBackend::DeleteShortcutsWithURL(const GURL& url,
   ShortcutsDatabase::ShortcutIDs shortcut_ids;
   for (GuidMap::iterator it(guid_map_.begin()); it != guid_map_.end(); ) {
     if (exact_match ? (it->second->second.match_core.destination_url == url)
-                    : base::StartsWithASCII(
+                    : base::StartsWith(
                           it->second->second.match_core.destination_url.spec(),
-                          url_spec, true)) {
+                          url_spec, base::CompareCase::SENSITIVE)) {
       shortcut_ids.push_back(it->first);
       shortcuts_map_.erase(it->second);
       guid_map_.erase(it++);
diff --git a/components/omnibox/shortcuts_provider.cc b/components/omnibox/shortcuts_provider.cc
index 03d44f7..6b33313 100644
--- a/components/omnibox/shortcuts_provider.cc
+++ b/components/omnibox/shortcuts_provider.cc
@@ -136,7 +136,8 @@ void ShortcutsProvider::GetMatches(const AutocompleteInput& input) {
   for (ShortcutsBackend::ShortcutMap::const_iterator it =
            FindFirstMatch(term_string, backend.get());
        it != backend->shortcuts_map().end() &&
-           base::StartsWith(it->first, term_string, true);
+           base::StartsWith(it->first, term_string,
+                            base::CompareCase::SENSITIVE);
        ++it) {
     // Don't return shortcuts with zero relevance.
     int relevance = CalculateScore(term_string, it->second, max_relevance);
@@ -217,7 +218,9 @@ AutocompleteMatch ShortcutsProvider::ShortcutToACMatch(
   // input of "foo.c" to autocomplete to "foo.com" for a fill_into_edit of
   // "http://foo.com".
   if (AutocompleteMatch::IsSearchType(match.type)) {
-    if (base::StartsWith(match.fill_into_edit, input.text(), false)) {
+    if (base::StartsWith(base::i18n::ToLower(match.fill_into_edit),
+                         base::i18n::ToLower(input.text()),
+                         base::CompareCase::SENSITIVE)) {
       match.inline_autocompletion =
           match.fill_into_edit.substr(input.text().length());
       match.allowed_to_be_default_match =
@@ -305,7 +308,8 @@ ACMatchClassifications ShortcutsProvider::ClassifyAllMatchesInString(
   base::string16 text_lowercase(base::i18n::ToLower(text));
   ACMatchClassifications match_class;
   size_t last_position = 0;
-  if (base::StartsWith(text_lowercase, find_text, true)) {
+  if (base::StartsWith(text_lowercase, find_text,
+                       base::CompareCase::SENSITIVE)) {
     match_class.push_back(
         ACMatchClassification(0, ACMatchClassification::MATCH));
     last_position = find_text.length();
@@ -369,7 +373,7 @@ ShortcutsBackend::ShortcutMap::const_iterator ShortcutsProvider::FindFirstMatch(
   // Lower bound not necessarily matches the keyword, check for item pointed by
   // the lower bound iterator to at least start with keyword.
   return ((it == backend->shortcuts_map().end()) ||
-          base::StartsWith(it->first, keyword, true))
+          base::StartsWith(it->first, keyword, base::CompareCase::SENSITIVE))
              ? it
              : backend->shortcuts_map().end();
 }
diff --git a/components/omnibox/url_index_private_data.cc b/components/omnibox/url_index_private_data.cc
index 2d254ef..5cc800b 100644
--- a/components/omnibox/url_index_private_data.cc
+++ b/components/omnibox/url_index_private_data.cc
@@ -563,10 +563,13 @@ HistoryIDSet URLIndexPrivateData::HistoryIDsForTerm(
   WordIDSet word_id_set;
   if (term_length > 1) {
     // See if this term or a prefix thereof is present in the cache.
+    base::string16 term_lower = base::i18n::ToLower(term);
     SearchTermCacheMap::iterator best_prefix(search_term_cache_.end());
     for (SearchTermCacheMap::iterator cache_iter = search_term_cache_.begin();
          cache_iter != search_term_cache_.end(); ++cache_iter) {
-      if (base::StartsWith(term, cache_iter->first, false) &&
+      if (base::StartsWith(term_lower,
+                           base::i18n::ToLower(cache_iter->first),
+                           base::CompareCase::SENSITIVE) &&
           (best_prefix == search_term_cache_.end() ||
            cache_iter->first.length() > best_prefix->first.length()))
         best_prefix = cache_iter;