Replace more for loops in GN

tools/gn/command_desc.cc

 // Copyright (c) 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 <algorithm>
 #include <set>
 #include <sstream>
 
 #include "base/command_line.h"
 #include "tools/gn/commands.h"
@@ skipping 53 matching lines @@
                         std::set<const Target*>* seen_targets,
                         int indent_level) {
   // Combine all deps into one sorted list.
   std::vector<LabelTargetPair> sorted_deps;
   for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
     sorted_deps.push_back(pair);
   std::sort(sorted_deps.begin(), sorted_deps.end(),
             LabelPtrLabelLess<Target>());
 
   std::string indent(indent_level * 2, ' ');
-  for (size_t i = 0; i < sorted_deps.size(); i++) {
-    const Target* cur_dep = sorted_deps[i].ptr;
+  for (const auto& pair : sorted_deps) {
+    const Target* cur_dep = pair.ptr;
 
     OutputString(indent +
         cur_dep->label().GetUserVisibleName(default_toolchain));
     bool print_children = true;
     if (seen_targets) {
       if (seen_targets->find(cur_dep) == seen_targets->end()) {
         // New target, mark it visited.
         seen_targets->insert(cur_dep);
       } else {
         // Already seen.
@@ skipping 37 matching lines @@
 
   // Collect the deps to display.
   std::vector<Label> deps;
   if (cmdline->HasSwitch("all")) {
     // Show all dependencies.
     if (display_header)
       OutputString("\nAll recursive dependencies:\n");
 
     std::set<Label> all_deps;
     RecursiveCollectChildDeps(target, &all_deps);
-    for (std::set<Label>::iterator i = all_deps.begin();
-         i != all_deps.end(); ++i)
-      deps.push_back(*i);
+    for (const auto& dep : all_deps)
+      deps.push_back(dep);
   } else {
     // Show direct dependencies only.
     if (display_header) {
       OutputString(
           "\nDirect dependencies "
           "(try also \"--all\", \"--tree\", or even \"--all --tree\"):\n");
     }
     for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
       deps.push_back(pair.label);
   }
 
   std::sort(deps.begin(), deps.end());
-  for (size_t i = 0; i < deps.size(); i++)
-    OutputString("  " + deps[i].GetUserVisibleName(toolchain_label) + "\n");
+  for (const auto& dep : deps)
+    OutputString("  " + dep.GetUserVisibleName(toolchain_label) + "\n");
 }
 
 void PrintForwardDependentConfigsFrom(const Target* target,
                                       bool display_header) {
   if (target->forward_dependent_configs().empty())
     return;
 
   if (display_header)
     OutputString("\nforward_dependent_configs_from:\n");
 
   // Collect the sorted list of deps.
   std::vector<Label> forward;
-  for (size_t i = 0; i < target->forward_dependent_configs().size(); i++)
-    forward.push_back(target->forward_dependent_configs()[i].label);
+  for (const auto& pair : target->forward_dependent_configs())
+    forward.push_back(pair.label);
   std::sort(forward.begin(), forward.end());
 
   Label toolchain_label = target->label().GetToolchainLabel();
-  for (size_t i = 0; i < forward.size(); i++)
-    OutputString("  " + forward[i].GetUserVisibleName(toolchain_label) + "\n");
+  for (const auto& fwd : forward)
+    OutputString("  " + fwd.GetUserVisibleName(toolchain_label) + "\n");
 }
 
 // libs and lib_dirs are special in that they're inherited. We don't currently
 // implement a blame feature for this since the bottom-up inheritance makes
 // this difficult.
 void PrintLibDirs(const Target* target, bool display_header) {
   const OrderedSet<SourceDir>& lib_dirs = target->all_lib_dirs();
   if (lib_dirs.empty())
     return;
 
@@ skipping 20 matching lines @@
   if (display_header)
     OutputString("\npublic:\n");
 
   if (target->all_headers_public()) {
     OutputString("  [All headers listed in the sources are public.]\n");
     return;
   }
 
   Target::FileList public_headers = target->public_headers();
   std::sort(public_headers.begin(), public_headers.end());
-  for (size_t i = 0; i < public_headers.size(); i++)
-    OutputString("  " + public_headers[i].value() + "\n");
+  for (const auto& hdr : public_headers)
+    OutputString("  " + hdr.value() + "\n");
 }
 
 void PrintCheckIncludes(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\ncheck_includes:\n");
 
   if (target->check_includes())
     OutputString("  true\n");
   else
     OutputString("  false\n");
 }
 
 void PrintAllowCircularIncludesFrom(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\nallow_circular_includes_from:\n");
 
   Label toolchain_label = target->label().GetToolchainLabel();
-  const std::set<Label>& allow = target->allow_circular_includes_from();
-  for (std::set<Label>::const_iterator iter = allow.begin();
-       iter != allow.end(); ++iter)
-    OutputString("  " + iter->GetUserVisibleName(toolchain_label) + "\n");
+  for (const auto& cur : target->allow_circular_includes_from())
+    OutputString("  " + cur.GetUserVisibleName(toolchain_label) + "\n");
 }
 
 void PrintVisibility(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\nvisibility:\n");
 
   OutputString(target->visibility().Describe(2, false));
 }
 
 void PrintTestonly(const Target* target, bool display_header) {
@@ skipping 460 matching lines @@
   // so always display them, even for groups and such.
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands