Revert 262747 "Improve GN public header file checking"

trunk/src/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.
@@ skipping 22 matching lines @@
 // 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, "//"))
     return false;  // Don't count comments.
   if (StartsWith(line, "#"))
     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) {
+                           base::StringPiece* path) {
   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)))
-    contents = TrimLeadingWhitespace(trimmed.substr(kIncludeLen));
-  else if (StartsWith(trimmed, base::StringPiece(kImport, kImportLen)))
-    contents = TrimLeadingWhitespace(trimmed.substr(kImportLen));
+  if (StartsWith(line, base::StringPiece(kInclude, kIncludeLen)))
+    contents = TrimLeadingWhitespace(line.substr(kIncludeLen));
+  else if (StartsWith(line, base::StringPiece(kImport, kImportLen)))
+    contents = TrimLeadingWhitespace(line.substr(kImportLen));
 
   if (contents.empty())
     return INCLUDE_NONE;
 
   IncludeType type = INCLUDE_NONE;
   char terminating_char = 0;
   if (contents[0] == '"') {
     type = INCLUDE_USER;
     terminating_char = '"';
   } else if (contents[0] == '<') {
     type = INCLUDE_SYSTEM;
     terminating_char = '>';
   } else {
     return INCLUDE_NONE;
   }
 
   // Count everything to next "/> as the contents.
   size_t terminator_index = contents.find(terminating_char, 1);
   if (terminator_index == base::StringPiece::npos)
     return INCLUDE_NONE;
 
   *path = contents.substr(1, terminator_index - 1);
-  // Note: one based so we do "+ 1".
-  *begin_char = static_cast<int>(path->data() - line.data()) + 1;
   return type;
 }
 
 }  // namespace
 
 const int CIncludeIterator::kMaxNonIncludeLines = 10;
 
-CIncludeIterator::CIncludeIterator(const InputFile* input)
-    : input_file_(input),
-      file_(input->contents()),
+CIncludeIterator::CIncludeIterator(const base::StringPiece& file)
+    : file_(file),
       offset_(0),
-      line_number_(0),
       lines_since_last_include_(0) {
 }
 
 CIncludeIterator::~CIncludeIterator() {
 }
 
-bool CIncludeIterator::GetNextIncludeString(base::StringPiece* out,
-                                            LocationRange* location) {
+bool CIncludeIterator::GetNextIncludeString(base::StringPiece* out) {
   base::StringPiece line;
-  int cur_line_number = 0;
   while (lines_since_last_include_ <= kMaxNonIncludeLines &&
-         GetNextLine(&line, &cur_line_number)) {
+         GetNextLine(&line)) {
+    base::StringPiece trimmed = TrimLeadingWhitespace(line);
+    if (trimmed.empty())
+      continue;  // Just ignore all empty lines.
+
     base::StringPiece include_contents;
-    int begin_char;
-    IncludeType type = ExtractInclude(line, &include_contents, &begin_char);
+    IncludeType type = ExtractInclude(trimmed, &include_contents);
     if (type == INCLUDE_USER) {
       // Only count user includes for now.
       *out = include_contents;
-      *location = LocationRange(
-          Location(input_file_, cur_line_number, begin_char),
-          Location(input_file_, cur_line_number,
-                   begin_char + include_contents.size()));
-
       lines_since_last_include_ = 0;
       return true;
     }
 
-    if (ShouldCountTowardNonIncludeLines(line))
+    if (ShouldCountTowardNonIncludeLines(trimmed))
       lines_since_last_include_++;
   }
   return false;
 }
 
-bool CIncludeIterator::GetNextLine(base::StringPiece* line, int* line_number) {
+bool CIncludeIterator::GetNextLine(base::StringPiece* line) {
   if (offset_ == file_.size())
     return false;
 
   size_t begin = offset_;
   while (offset_ < file_.size() && file_[offset_] != '\n')
     offset_++;
-  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;
 }