Replace more for loops in GN

tools/gn/args.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/args.h"
 
 #include "build/build_config.h"
 #include "tools/gn/variables.h"
 
 #if defined(OS_WIN)
@@ skipping 71 matching lines @@
 void Args::AddArgOverride(const char* name, const Value& value) {
   base::AutoLock lock(lock_);
 
   overrides_[base::StringPiece(name)] = value;
   all_overrides_[base::StringPiece(name)] = value;
 }
 
 void Args::AddArgOverrides(const Scope::KeyValueMap& overrides) {
   base::AutoLock lock(lock_);
 
-  for (Scope::KeyValueMap::const_iterator i = overrides.begin();
-       i != overrides.end(); ++i) {
-    overrides_[i->first] = i->second;
-    all_overrides_[i->first] = i->second;
+  for (const auto& cur_override : overrides) {
+    overrides_[cur_override.first] = cur_override.second;
+    all_overrides_[cur_override.first] = cur_override.second;
   }
 }
 
 const Value* Args::GetArgOverride(const char* name) const {
   base::AutoLock lock(lock_);
 
   Scope::KeyValueMap::const_iterator found =
       all_overrides_.find(base::StringPiece(name));
   if (found == all_overrides_.end())
     return NULL;
@@ skipping 13 matching lines @@
   ApplyOverridesLocked(overrides_, dest);
   ApplyOverridesLocked(toolchain_overrides, dest);
   SaveOverrideRecordLocked(toolchain_overrides);
 }
 
 bool Args::DeclareArgs(const Scope::KeyValueMap& args,
                        Scope* scope_to_set,
                        Err* err) const {
   base::AutoLock lock(lock_);
 
-  for (Scope::KeyValueMap::const_iterator i = args.begin();
-       i != args.end(); ++i) {
+  for (const auto& arg : args) {
     // Verify that the value hasn't already been declared. We want each value
     // to be declared only once.
     //
     // The tricky part is that a buildfile can be interpreted multiple times
     // when used from different toolchains, so we can't just check that we've
     // seen it before. Instead, we check that the location matches.
     Scope::KeyValueMap::iterator previously_declared =
-        declared_arguments_.find(i->first);
+        declared_arguments_.find(arg.first);
     if (previously_declared != declared_arguments_.end()) {
-      if (previously_declared->second.origin() != i->second.origin()) {
+      if (previously_declared->second.origin() != arg.second.origin()) {
         // Declaration location mismatch.
-        *err = Err(i->second.origin(), "Duplicate build argument declaration.",
+        *err = Err(arg.second.origin(),
+            "Duplicate build argument declaration.",
             "Here you're declaring an argument that was already declared "
             "elsewhere.\nYou can only declare each argument once in the entire "
             "build so there is one\ncanonical place for documentation and the "
             "default value. Either move this\nargument to the build config "
             "file (for visibility everywhere) or to a .gni file\nthat you "
             "\"import\" from the files where you need it (preferred).");
         err->AppendSubErr(Err(previously_declared->second.origin(),
                               "Previous declaration.",
                               "See also \"gn help buildargs\" for more on how "
                               "build arguments work."));
         return false;
       }
     } else {
-      declared_arguments_.insert(*i);
+      declared_arguments_.insert(arg);
     }
 
     // Only set on the current scope to the new value if it hasn't been already
     // set. Mark the variable used so the build script can override it in
     // certain cases without getting unused value errors.
-    if (!scope_to_set->GetValue(i->first)) {
-      scope_to_set->SetValue(i->first, i->second, i->second.origin());
-      scope_to_set->MarkUsed(i->first);
+    if (!scope_to_set->GetValue(arg.first)) {
+      scope_to_set->SetValue(arg.first, arg.second, arg.second.origin());
+      scope_to_set->MarkUsed(arg.first);
     }
   }
 
   return true;
 }
 
 bool Args::VerifyAllOverridesUsed(Err* err) const {
   base::AutoLock lock(lock_);
   return VerifyAllOverridesUsed(all_overrides_, declared_arguments_, err);
 }
 
 bool Args::VerifyAllOverridesUsed(
     const Scope::KeyValueMap& overrides,
     const Scope::KeyValueMap& declared_arguments,
     Err* err) {
-  for (Scope::KeyValueMap::const_iterator i = overrides.begin();
-       i != overrides.end(); ++i) {
-    if (declared_arguments.find(i->first) == declared_arguments.end()) {
+  for (const auto& override : overrides) {
+    if (declared_arguments.find(override.first) == declared_arguments.end()) {
       // Get a list of all possible overrides for help with error finding.
       //
       // It might be nice to do edit distance checks to see if we can find one
       // close to what you typed.
       std::string all_declared_str;
       for (Scope::KeyValueMap::const_iterator cur_str =
                declared_arguments.begin();
            cur_str != declared_arguments.end(); ++cur_str) {
         if (cur_str != declared_arguments.begin())
           all_declared_str += ", ";
         all_declared_str += cur_str->first.as_string();
       }
 
-      *err = Err(i->second.origin(), "Build argument has no effect.",
-          "The variable \"" + i->first.as_string() + "\" was set as a build "
+      *err = Err(override.second.origin(), "Build argument has no effect.",
+          "The variable \"" + override.first.as_string() +
+          "\" was set as a build "
           "argument\nbut never appeared in a declare_args() block in any "
           "buildfile.\n\nPossible arguments: " + all_declared_str);
       return false;
     }
   }
   return true;
 }
 
 void Args::MergeDeclaredArguments(Scope::KeyValueMap* dest) const {
   base::AutoLock lock(lock_);
-
-  for (Scope::KeyValueMap::const_iterator i = declared_arguments_.begin();
-       i != declared_arguments_.end(); ++i)
-    (*dest)[i->first] = i->second;
+  for (const auto& arg : declared_arguments_)
+    (*dest)[arg.first] = arg.second;
 }
 
 void Args::SetSystemVarsLocked(Scope* dest) const {
   lock_.AssertAcquired();
 
   // Host OS.
   const char* os = NULL;
 #if defined(OS_WIN)
   os = "win";
 #elif defined(OS_MACOSX)
@@ skipping 60 matching lines @@
   // without geting a warning about overwriting an unused variable.
   declared_arguments_[variables::kOs] = os_val;
   declared_arguments_[variables::kCpuArch] = arch_val;
   dest->MarkUsed(variables::kCpuArch);
   dest->MarkUsed(variables::kOs);
 }
 
 void Args::ApplyOverridesLocked(const Scope::KeyValueMap& values,
                                 Scope* scope) const {
   lock_.AssertAcquired();
-  for (Scope::KeyValueMap::const_iterator i = values.begin();
-       i != values.end(); ++i)
-    scope->SetValue(i->first, i->second, i->second.origin());
+  for (const auto& val : values)
+    scope->SetValue(val.first, val.second, val.second.origin());
 }
 
 void Args::SaveOverrideRecordLocked(const Scope::KeyValueMap& values) const {
   lock_.AssertAcquired();
-  for (Scope::KeyValueMap::const_iterator i = values.begin();
-       i != values.end(); ++i)
-    all_overrides_[i->first] = i->second;
+  for (const auto& val : values)
+    all_overrides_[val.first] = val.second;
 }