tools/gn: Convert for loops to use the new range-based loops in C++11.

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 312 matching lines @@
   // For all targets containing this file, we require that at least one be
   // a direct or public dependency of the current target, and that the header
   // is public within the target.
   //
   // If there is more than one target containing this header, we may encounter
   // some error cases before finding a good one. This error stores the previous
   // one encountered, which we may or may not throw away.
   Err last_error;
 
   bool found_dependency = false;
-  for (size_t i = 0; i < targets.size(); i++) {
+  for (const auto& target : targets) {
     // We always allow source files in a target to include headers also in that
     // target.
-    const Target* to_target = targets[i].target;
+    const Target* to_target = target.target;
     if (to_target == from_target)
       return true;
 
     // Additionally, allow a target to include files from that same target
     // in other toolchains. This is a bit of a hack to account for the fact that
     // the include finder doesn't understand the preprocessor.
     //
     // If a source file conditionally depends on a platform-specific include in
     // the same target, and there is a cross-compile such that GN sees
     // definitions of the target both with and without that include, it would
     // give an error that the target needs to depend on itself in the other
     // toolchain (where the platform-specific header is defined as a source).
     if (TargetLabelsMatchExceptToolchain(to_target, from_target))
       return true;
 
     bool is_permitted_chain = false;
     if (IsDependencyOf(to_target, from_target, &chain, &is_permitted_chain)) {
       DCHECK(chain.size() >= 2);
       DCHECK(chain[0].target == to_target);
       DCHECK(chain[chain.size() - 1].target == from_target);
 
       found_dependency = true;
 
-      if (targets[i].is_public && is_permitted_chain) {
+      if (target.is_public && is_permitted_chain) {
         // This one is OK, we're done.
         last_error = Err();
         break;
       }
 
       // Diagnose the error.
-      if (!targets[i].is_public) {
+      if (!target.is_public) {
         // Danger: must call CreatePersistentRange to put in Err.
-        last_error = Err(
-            CreatePersistentRange(source_file, range),
-            "Including a private header.",
-            "This file is private to the target " +
-                targets[i].target->label().GetUserVisibleName(false));
+        last_error = Err(CreatePersistentRange(source_file, range),
+                         "Including a private header.",
+                         "This file is private to the target " +
+                             target.target->label().GetUserVisibleName(false));
       } else if (!is_permitted_chain) {
         last_error = Err(
             CreatePersistentRange(source_file, range),
             "Can't include this header from here.",
                 GetDependencyChainPublicError(chain));
       } else {
         NOTREACHED();
       }
     } else if (
         to_target->allow_circular_includes_from().find(from_target->label()) !=
@@ skipping 176 matching lines @@
   if (targets_with_other_toolchains.size() +
       targets_with_matching_toolchains.size() > 1)
     msg += "at least one of ";
   msg += "which should somehow be reachable.";
 
   // Danger: must call CreatePersistentRange to put in Err.
   return Err(CreatePersistentRange(source_file, range),
              "Include not allowed.", msg);
 }