Replace more for loops in GN

tools/gn/header_checker.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/header_checker.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 103 matching lines @@
   }
   return ret;
 }
 
 }  // namespace
 
 HeaderChecker::HeaderChecker(const BuildSettings* build_settings,
                              const std::vector<const Target*>& targets)
     : main_loop_(base::MessageLoop::current()),
       build_settings_(build_settings) {
-  for (size_t i = 0; i < targets.size(); i++)
-    AddTargetToFileMap(targets[i], &file_map_);
+  for (const auto& target : targets)
+    AddTargetToFileMap(target, &file_map_);
 }
 
 HeaderChecker::~HeaderChecker() {
 }
 
 bool HeaderChecker::Run(const std::vector<const Target*>& to_check,
                         bool force_check,
                         std::vector<Err>* errors) {
   if (to_check.empty()) {
     // Check all files.
     RunCheckOverFiles(file_map_, force_check);
   } else {
     // Run only over the files in the given targets.
     FileMap files_to_check;
-    for (size_t i = 0; i < to_check.size(); i++)
-      AddTargetToFileMap(to_check[i], &files_to_check);
+    for (const auto& check : to_check)
+      AddTargetToFileMap(check, &files_to_check);
     RunCheckOverFiles(files_to_check, force_check);
   }
 
   if (errors_.empty())
     return true;
   *errors = errors_;
   return false;
 }
 
 void HeaderChecker::RunCheckOverFiles(const FileMap& files, bool force_check) {
   if (files.empty())
     return;
 
   scoped_refptr<base::SequencedWorkerPool> pool(
       new base::SequencedWorkerPool(16, "HeaderChecker"));
-  for (FileMap::const_iterator file_i = files.begin();
-       file_i != files.end(); ++file_i) {
-    const TargetVector& vect = file_i->second;
-
+  for (const auto& file : files) {
     // Only check C-like source files (RC files also have includes).
-    SourceFileType type = GetSourceFileType(file_i->first);
+    SourceFileType type = GetSourceFileType(file.first);
     if (type != SOURCE_CC && type != SOURCE_H && type != SOURCE_C &&
         type != SOURCE_M && type != SOURCE_MM && type != SOURCE_RC)
       continue;
 
     // Do a first pass to find if this should be skipped. All targets including
     // this source file must exclude it from checking, or any target
     // must mark it as generated (for cases where one target generates a file,
     // and another lists it as a source to compile it).
     if (!force_check) {
       bool check_includes = false;
       bool is_generated = false;
-      for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i) {
-        check_includes |= vect[vect_i].target->check_includes();
-        is_generated |= vect[vect_i].is_generated;
+      for (const auto& vect_i : file.second) {
+        check_includes |= vect_i.target->check_includes();
+        is_generated |= vect_i.is_generated;
       }
       if (!check_includes || is_generated)
         continue;
     }
 
-    for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i) {
+    for (const auto& vect_i : file.second) {
       pool->PostWorkerTaskWithShutdownBehavior(
           FROM_HERE,
-          base::Bind(&HeaderChecker::DoWork, this,
-                     vect[vect_i].target, file_i->first),
+          base::Bind(&HeaderChecker::DoWork, this, vect_i.target, file.first),
           base::SequencedWorkerPool::BLOCK_SHUTDOWN);
     }
   }
 
   // After this call we're single-threaded again.
   pool->Shutdown();
 }
 
 void HeaderChecker::DoWork(const Target* target, const SourceFile& file) {
   Err err;
   if (!CheckFile(target, file, &err)) {
     base::AutoLock lock(lock_);
     errors_.push_back(err);
   }
 }
 
 // static
 void HeaderChecker::AddTargetToFileMap(const Target* target, FileMap* dest) {
   // Files in the sources have this public bit by default.
   bool default_public = target->all_headers_public();
 
   std::map<SourceFile, PublicGeneratedPair> files_to_public;
 
   // First collect the normal files, they get the default visibility. Always
   // trim the root gen dir if it exists. This will only exist on outputs of an
   // action, but those are often then wired into the sources of a compiled
   // target to actually compile generated code. If you depend on the compiled
   // target, it should be enough to be able to include the header.
-  const Target::FileList& sources = target->sources();
-  for (size_t i = 0; i < sources.size(); i++) {
-    SourceFile file = RemoveRootGenDirFromFile(target, sources[i]);
+  for (const auto& source : target->sources()) {
+    SourceFile file = RemoveRootGenDirFromFile(target, source);
     files_to_public[file].is_public = default_public;
   }
 
   // Add in the public files, forcing them to public. This may overwrite some
   // entries, and it may add new ones.
-  const Target::FileList& public_list = target->public_headers();
-  if (default_public)
-    DCHECK(public_list.empty());  // List only used when default is not public.
-  for (size_t i = 0; i < public_list.size(); i++) {
-    SourceFile file = RemoveRootGenDirFromFile(target, public_list[i]);
+  if (default_public)  // List only used when default is not public.
+    DCHECK(target->public_headers().empty());
+  for (const auto& source : target->public_headers()) {
+    SourceFile file = RemoveRootGenDirFromFile(target, source);
     files_to_public[file].is_public = true;
   }
 
   // Add in outputs from actions. These are treated as public (since if other
   // targets can't use them, then there wouldn't be any point in outputting).
   std::vector<SourceFile> outputs;
   target->action_values().GetOutputsAsSourceFiles(target, &outputs);
-  for (size_t i = 0; i < outputs.size(); i++) {
+  for (const auto& output : outputs) {
     // For generated files in the "gen" directory, add the filename to the
     // map assuming "gen" is the source root. This means that when files include
     // the generated header relative to there (the recommended practice), we'll
     // find the file.
-    SourceFile output_file = RemoveRootGenDirFromFile(target, outputs[i]);
+    SourceFile output_file = RemoveRootGenDirFromFile(target, output);
     PublicGeneratedPair* pair = &files_to_public[output_file];
     pair->is_public = true;
     pair->is_generated = true;
   }
 
   // Add the merged list to the master list of all files.
-  for (std::map<SourceFile, PublicGeneratedPair>::const_iterator i =
-           files_to_public.begin();
-       i != files_to_public.end(); ++i) {
-    (*dest)[i->first].push_back(TargetInfo(
-        target, i->second.is_public, i->second.is_generated));
+  for (const auto& cur : files_to_public) {
+    (*dest)[cur.first].push_back(TargetInfo(
+        target, cur.second.is_public, cur.second.is_generated));
   }
 }
 
 bool HeaderChecker::IsFileInOuputDir(const SourceFile& file) const {
   const std::string& build_dir = build_settings_->build_dir().value();
   return file.value().compare(0, build_dir.size(), build_dir) == 0;
 }
 
 // This current assumes all include paths are relative to the source root
 // which is generally the case for Chromium.
@@ skipping 127 matching lines @@
       break;
     }
   }
 
   if (!found_dependency) {
     DCHECK(!last_error.has_error());
 
     std::string msg = "It is not in any dependency of " +
         from_target->label().GetUserVisibleName(false);
     msg += "\nThe include file is in the target(s):\n";
-    for (size_t i = 0; i < targets.size(); i++)
-      msg += "  " + targets[i].target->label().GetUserVisibleName(false) + "\n";
+    for (const auto& target : targets)
+      msg += "  " + target.target->label().GetUserVisibleName(false) + "\n";
     if (targets.size() > 1)
       msg += "at least one of ";
     msg += "which should somehow be reachable from " +
         from_target->label().GetUserVisibleName(false);
 
     // Danger: must call CreatePersistentRange to put in Err.
     *err = Err(CreatePersistentRange(source_file, range),
                "Include not allowed.", msg);
     return false;
   }
@@ skipping 84 matching lines @@
       while (target != search_from) {
         chain->push_back(cur_link);
         cur_link = breadcrumbs[target];
         target = cur_link.target;
       }
       chain->push_back(ChainLink(search_from, true));
       return true;
     }
 
     // Always consider public dependencies as possibilities.
-    const LabelTargetVector& public_deps = target->public_deps();
-    for (size_t i = 0; i < public_deps.size(); i++) {
-      if (breadcrumbs.insert(
-              std::make_pair(public_deps[i].ptr, cur_link)).second)
-        work_queue.push(ChainLink(public_deps[i].ptr, true));
+    for (const auto& dep : target->public_deps()) {
+      if (breadcrumbs.insert(std::make_pair(dep.ptr, cur_link)).second)
+        work_queue.push(ChainLink(dep.ptr, true));
     }
 
     if (first_time || !require_permitted) {
       // Consider all dependencies since all target paths are allowed, so add
       // in private ones. Also do this the first time through the loop, since
       // a target can include headers from its direct deps regardless of
       // public/private-ness.
       first_time = false;
-      const LabelTargetVector& private_deps = target->private_deps();
-      for (size_t i = 0; i < private_deps.size(); i++) {
-        if (breadcrumbs.insert(
-                std::make_pair(private_deps[i].ptr, cur_link)).second)
-          work_queue.push(ChainLink(private_deps[i].ptr, false));
+      for (const auto& dep : target->private_deps()) {
+        if (breadcrumbs.insert(std::make_pair(dep.ptr, cur_link)).second)
+          work_queue.push(ChainLink(dep.ptr, false));
       }
     }
   }
 
   return false;
 }