Replace more for loops in GN

tools/gn/loader.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/loader.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "tools/gn/build_settings.h"
@@ skipping 247 matching lines @@
 
   Err err;
   root->Execute(&our_scope, &err);
   if (err.has_error())
     g_scheduler->FailWithError(err);
 
   if (!our_scope.CheckForUnusedVars(&err))
     g_scheduler->FailWithError(err);
 
   // Pass all of the items that were defined off to the builder.
-  for (size_t i = 0; i < collected_items.size(); i++)
-    settings->build_settings()->ItemDefined(collected_items[i]->Pass());
+  for (const auto& item : collected_items)
+    settings->build_settings()->ItemDefined(item->Pass());
 
   trace.Done();
 
   main_loop_->PostTask(FROM_HERE, base::Bind(&LoaderImpl::DidLoadFile, this));
 }
 
 void LoaderImpl::BackgroundLoadBuildConfig(
     Settings* settings,
     const Scope::KeyValueMap& toolchain_overrides,
     const ParseNode* root) {
@@ skipping 84 matching lines @@
     record->settings.set_default_toolchain_label(label);
 
     // The settings object should have the toolchain label already set.
     DCHECK(!record->settings.toolchain_label().is_null());
 
     // Update any stored invocations that refer to the empty toolchain label.
     // This will normally only be one, for the root build file, so brute-force
     // is OK.
     LoadIDSet old_loads;
     invocations_.swap(old_loads);
-    for (LoadIDSet::iterator i = old_loads.begin();
-         i != old_loads.end(); ++i) {
-      if (i->toolchain_name.is_null()) {
+    for (const auto& load : old_loads) {
+      if (load.toolchain_name.is_null()) {
         // Fix up toolchain label
-        invocations_.insert(LoadID(i->file, label));
+        invocations_.insert(LoadID(load.file, label));
       } else {
         // Can keep the old one.
-        invocations_.insert(*i);
+        invocations_.insert(load);
       }
     }
   } else {
     record = found_toolchain->second;
   }
 
   DCHECK(!record->is_config_loaded);
   DCHECK(record->is_toolchain_loaded);
   record->is_config_loaded = true;
 
   // Schedule all waiting file loads.
-  for (size_t i = 0; i < record->waiting_on_me.size(); i++) {
-    ScheduleLoadFile(&record->settings, record->waiting_on_me[i].origin,
-                     record->waiting_on_me[i].file);
-  }
+  for (const auto& waiting : record->waiting_on_me)
+    ScheduleLoadFile(&record->settings, waiting.origin, waiting.file);
   record->waiting_on_me.clear();
 
   DecrementPendingLoads();
 }
 
 void LoaderImpl::DecrementPendingLoads() {
   DCHECK(pending_loads_ > 0);
   pending_loads_--;
   if (pending_loads_ == 0 && !complete_callback_.is_null())
     complete_callback_.Run();
 }
 
 bool LoaderImpl::AsyncLoadFile(
     const LocationRange& origin,
     const BuildSettings* build_settings,
     const SourceFile& file_name,
     const base::Callback<void(const ParseNode*)>& callback,
     Err* err) {
   if (async_load_file_.is_null()) {
     return g_scheduler->input_file_manager()->AsyncLoadFile(
         origin, build_settings, file_name, callback, err);
   }
   return async_load_file_.Run(
       origin, build_settings, file_name, callback, err);
 }