Replace more for loops in GN

tools/gn/trace.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 "tools/gn/trace.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 #include <vector>
@@ skipping 47 matching lines @@
 
 bool CoalescedDurationGreater(const Coalesced& a, const Coalesced& b) {
   return a.total_duration > b.total_duration;
 }
 
 void SummarizeParses(std::vector<const TraceItem*>& loads,
                      std::ostream& out) {
   out << "File parse times: (time in ms, name)\n";
 
   std::sort(loads.begin(), loads.end(), &DurationGreater);
-
-  for (size_t i = 0; i < loads.size(); i++) {
-    out << base::StringPrintf(" %8.2f  ",
-                              loads[i]->delta().InMillisecondsF());
-    out << loads[i]->name() << std::endl;
+  for (const auto* load : loads) {

[scottmg, 2014/09/30 19:31:47]

*?

+    out << base::StringPrintf(" %8.2f  ", load->delta().InMillisecondsF());
+    out << load->name() << std::endl;
   }
 }
 
 void SummarizeCoalesced(std::vector<const TraceItem*>& items,
                         std::ostream& out) {
   // Group by file name.
   std::map<std::string, Coalesced> coalesced;
-  for (size_t i = 0; i < items.size(); i++) {
-    Coalesced& c = coalesced[items[i]->name()];
-    c.name_ptr = &items[i]->name();
-    c.total_duration += items[i]->delta().InMillisecondsF();
+  for (const auto& item : items) {
+    Coalesced& c = coalesced[item->name()];
+    c.name_ptr = &item->name();
+    c.total_duration += item->delta().InMillisecondsF();
     c.count++;
   }
 
   // Sort by duration.
   std::vector<Coalesced> sorted;
-  for (std::map<std::string, Coalesced>::iterator iter = coalesced.begin();
-       iter != coalesced.end(); ++iter)
-    sorted.push_back(iter->second);
+  for (const auto& pair : coalesced)
+    sorted.push_back(pair.second);
   std::sort(sorted.begin(), sorted.end(), &CoalescedDurationGreater);
 
-  for (size_t i = 0; i < sorted.size(); i++) {
-    out << base::StringPrintf(" %8.2f  %d  ",
-                              sorted[i].total_duration, sorted[i].count);
-    out << *sorted[i].name_ptr << std::endl;
+  for (const auto& cur : sorted) {
+    out << base::StringPrintf(" %8.2f  %d  ", cur.total_duration, cur.count);
+    out << *cur.name_ptr << std::endl;
   }
 }
 
 void SummarizeFileExecs(std::vector<const TraceItem*>& execs,
                         std::ostream& out) {
   out << "File execute times: (total time in ms, # executions, name)\n";
   SummarizeCoalesced(execs, out);
 }
 
 void SummarizeScriptExecs(std::vector<const TraceItem*>& execs,
@@ skipping 72 matching lines @@
     return std::string();
 
   std::vector<TraceItem*> events = trace_log->events();
 
   // Classify all events.
   std::vector<const TraceItem*> parses;
   std::vector<const TraceItem*> file_execs;
   std::vector<const TraceItem*> script_execs;
   std::vector<const TraceItem*> check_headers;
   int headers_checked = 0;
-  for (size_t i = 0; i < events.size(); i++) {
-    switch (events[i]->type()) {
+  for (const auto& event : events) {
+    switch (event->type()) {
       case TraceItem::TRACE_FILE_PARSE:
-        parses.push_back(events[i]);
+        parses.push_back(event);
         break;
       case TraceItem::TRACE_FILE_EXECUTE:
-        file_execs.push_back(events[i]);
+        file_execs.push_back(event);
         break;
       case TraceItem::TRACE_SCRIPT_EXECUTE:
-        script_execs.push_back(events[i]);
+        script_execs.push_back(event);
         break;
       case TraceItem::TRACE_CHECK_HEADERS:
-        check_headers.push_back(events[i]);
+        check_headers.push_back(event);
         break;
       case TraceItem::TRACE_CHECK_HEADER:
         headers_checked++;
         break;
       case TraceItem::TRACE_SETUP:
       case TraceItem::TRACE_FILE_LOAD:
       case TraceItem::TRACE_FILE_WRITE:
       case TraceItem::TRACE_DEFINE_TARGET:
         break;  // Ignore these for the summary.
     }
   }
 
   std::ostringstream out;
   SummarizeParses(parses, out);
   out << std::endl;
   SummarizeFileExecs(file_execs, out);
   out << std::endl;
   SummarizeScriptExecs(script_execs, out);
   out << std::endl;
 
   // Generally there will only be one header check, but it's theoretically
   // possible for more than one to run if more than one build is going in
   // parallel. Just report the total of all of them.
   if (!check_headers.empty()) {
     float check_headers_time = 0;
-    for (size_t i = 0; i < check_headers.size(); i++)
-      check_headers_time += check_headers[i]->delta().InMillisecondsF();
+    for (const auto& cur : check_headers)
+      check_headers_time += cur->delta().InMillisecondsF();
 
     out << "Header check time: (total time in ms, files checked)\n";
     out << base::StringPrintf(" %8.2f  %d\n",
                               check_headers_time, headers_checked);
   }
 
   return out.str();
 }
 
 void SaveTraces(const base::FilePath& file_name) {
@@ skipping 76 matching lines @@
     }
     out << "}";
   }
 
   out << "]}";
 
   std::string out_str = out.str();
   base::WriteFile(file_name, out_str.data(),
                        static_cast<int>(out_str.size()));
 }