tools/gn: make use of base's StartsWith() function

tools/gn/c_include_iterator.cc

 // Copyright 2014 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 "tools/gn/c_include_iterator.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/location.h"
 
 namespace {
 
 enum IncludeType {
   INCLUDE_NONE,
   INCLUDE_SYSTEM,  // #include <...>
   INCLUDE_USER     // #include "..."
 };
 
-// Returns true if str starts with the prefix.
-bool StartsWith(const base::StringPiece& str, const base::StringPiece& prefix) {
-  base::StringPiece extracted = str.substr(0, prefix.size());
-  return extracted == prefix;
-}
-
 // Returns a new string piece referencing the same buffer as the argument, but
 // with leading space trimmed. This only checks for space and tab characters
 // since we're dealing with lines in C source files.
 base::StringPiece TrimLeadingWhitespace(const base::StringPiece& str) {
   size_t new_begin = 0;
   while (new_begin < str.size() &&
          (str[new_begin] == ' ' || str[new_begin] == '\t'))
     new_begin++;
   return str.substr(new_begin);
 }
 
 // We don't want to count comment lines and preprocessor lines toward our
 // "max lines to look at before giving up" since the beginnings of some files
 // may have a lot of comments.
 //
 // We only handle C-style "//" comments since this is the normal commenting
 // style used in Chrome, and do so pretty stupidly. We don't want to write a
 // full C++ parser here, we're just trying to get a good heuristic for checking
 // the file.
 //
 // We assume the line has leading whitespace trimmed. We also assume that empty
 // lines have already been filtered out.
 bool ShouldCountTowardNonIncludeLines(const base::StringPiece& line) {
-  if (StartsWith(line, "//"))
+  if (base::StartsWith(line, "//", base::CompareCase::SENSITIVE))
     return false;  // Don't count comments.
-  if (StartsWith(line, "/*") || StartsWith(line, " *"))
+  if (base::StartsWith(line, "/*", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(line, " *", base::CompareCase::SENSITIVE))
     return false;  // C-style comment blocks with stars along the left side.
-  if (StartsWith(line, "#"))
+  if (base::StartsWith(line, "#", base::CompareCase::SENSITIVE))
     return false;  // Don't count preprocessor.
   if (base::ContainsOnlyChars(line, base::kWhitespaceASCII))
     return false;  // Don't count whitespace lines.
   return true;  // Count everything else.
 }
 
 // Given a line, checks to see if it looks like an include or import and
 // extract the path. The type of include is returned. Returns INCLUDE_NONE on
 // error or if this is not an include line.
 //
 // The 1-based character number on the line that the include was found at
 // will be filled into *begin_char.
 IncludeType ExtractInclude(const base::StringPiece& line,
                            base::StringPiece* path,
                            int* begin_char) {
   static const char kInclude[] = "#include";
   static const size_t kIncludeLen = arraysize(kInclude) - 1;  // No null.
   static const char kImport[] = "#import";
   static const size_t kImportLen = arraysize(kImport) - 1;  // No null.
 
   base::StringPiece trimmed = TrimLeadingWhitespace(line);
   if (trimmed.empty())
     return INCLUDE_NONE;
 
   base::StringPiece contents;
-  if (StartsWith(trimmed, base::StringPiece(kInclude, kIncludeLen)))
+  if (base::StartsWith(trimmed, base::StringPiece(kInclude, kIncludeLen),
+                       base::CompareCase::SENSITIVE))
     contents = TrimLeadingWhitespace(trimmed.substr(kIncludeLen));
-  else if (StartsWith(trimmed, base::StringPiece(kImport, kImportLen)))
+  else if (base::StartsWith(trimmed, base::StringPiece(kImport, kImportLen),
+                            base::CompareCase::SENSITIVE))
     contents = TrimLeadingWhitespace(trimmed.substr(kImportLen));
 
   if (contents.empty())
     return INCLUDE_NONE;
 
   IncludeType type = INCLUDE_NONE;
   char terminating_char = 0;
   if (contents[0] == '"') {
     type = INCLUDE_USER;
     terminating_char = '"';
@@ skipping 77 matching lines @@
   line_number_++;
 
   *line = file_.substr(begin, offset_ - begin);
   *line_number = line_number_;
 
   // If we didn't hit EOF, skip past the newline for the next one.
   if (offset_ < file_.size())
     offset_++;
   return true;
 }