Move StartsWith[ASCII] to base namespace.

chrome/tools/profile_reset/jtl_compiler_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/tools/profile_reset/jtl_compiler.h"
 
 #include <string>
 
 #include "base/values.h"
 #include "chrome/browser/profile_resetter/jtl_foundation.h"
@@ skipping 95 matching lines @@
   EXPECT_EQ(expected_bytecode, bytecode);
 }
 
 TEST(JtlCompiler, InvalidOperationName) {
   const char kSourceCode[] = "any()\n.\nnon_existent_instruction\n(\n)\n;\n";
 
   std::string bytecode;
   JtlCompiler::CompileError error;
   EXPECT_FALSE(
       JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error));
-  EXPECT_THAT(error.context, testing::StartsWith("non_existent_instruction"));
+  EXPECT_THAT(error.context,
+              testing::base::StartsWith("non_existent_instruction"));
   EXPECT_EQ(2u, error.line_number);
   EXPECT_EQ(JtlCompiler::CompileError::INVALID_OPERATION_NAME,
             error.error_code);
 }
 
 TEST(JtlCompiler, InvalidArgumentsCount) {
   const char* const kSourceCodes[] = {
       "any().\nstore_bool(\"name\", true, \"superfluous argument\");\n",
       "any().\nstore_bool(\"name\");"};  // missing argument
 
   for (size_t i = 0; i < arraysize(kSourceCodes); ++i) {
     SCOPED_TRACE(kSourceCodes[i]);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         kSourceCodes[i], kTestHashSeed, &bytecode, &error));
-    EXPECT_THAT(error.context, testing::StartsWith("store_bool"));
+    EXPECT_THAT(error.context, testing::base::StartsWith("store_bool"));
     EXPECT_EQ(1u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_COUNT,
               error.error_code);
   }
 }
 
 TEST(JtlCompiler, InvalidArgumentType) {
   struct TestCase {
     std::string expected_context_prefix;
     std::string source_code;
@@ skipping 11 matching lines @@
         {"compare_substring_hashed",
          "any()\n.\ncompare_substring_hashed(true);"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].source_code);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         cases[i].source_code, kTestHashSeed, &bytecode, &error));
     EXPECT_THAT(error.context,
-                testing::StartsWith(cases[i].expected_context_prefix));
+                testing::base::StartsWith(cases[i].expected_context_prefix));
     EXPECT_EQ(2u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_TYPE,
               error.error_code);
   }
 }
 
 TEST(JtlCompiler, InvalidArgumentValue) {
   struct TestCase {
     std::string expected_context_prefix;
     std::string source_code;
   } cases[] = {
         {"compare_substring_hashed", "compare_substring_hashed(\"\");"}};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].source_code);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         cases[i].source_code, kTestHashSeed, &bytecode, &error));
     EXPECT_THAT(error.context,
-                testing::StartsWith(cases[i].expected_context_prefix));
+                testing::base::StartsWith(cases[i].expected_context_prefix));
     EXPECT_EQ(0u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_VALUE,
               error.error_code);
   }
 }
 
 TEST(JtlCompiler, MistmatchedDoubleQuotes) {
   const char kSourceCode[] = "any().\ngo(\"ok\", \"stray quote).break();";
 
   std::string bytecode;
   JtlCompiler::CompileError error;
   EXPECT_FALSE(
       JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error));
   EXPECT_EQ(1u, error.line_number);
   EXPECT_EQ(JtlCompiler::CompileError::MISMATCHED_DOUBLE_QUOTES,
             error.error_code);
 }
 
 TEST(JtlCompiler, ParsingError) {
   const char kSourceCode[] = "any().\ngo()missing_separator();";
 
   std::string bytecode;
   JtlCompiler::CompileError error;
   EXPECT_FALSE(
       JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error));
-  EXPECT_THAT(error.context, testing::StartsWith("go"));
+  EXPECT_THAT(error.context, testing::base::StartsWith("go"));
   EXPECT_EQ(1u, error.line_number);
   EXPECT_EQ(JtlCompiler::CompileError::PARSING_ERROR, error.error_code);
 }
 
 }  // namespace