Check for GN args using the union of all rather than individually.

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 75 matching lines @@
 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;
   return &found->second;
 }
 
+Scope::KeyValueMap Args::GetAllOverrides() const {
+  base::AutoLock lock(lock_);
+  return all_overrides_;
+}
+
 void Args::SetupRootScope(Scope* dest,
                           const Scope::KeyValueMap& toolchain_overrides) const {
   base::AutoLock lock(lock_);
 
   SetSystemVarsLocked(dest);
   ApplyOverridesLocked(overrides_, dest);
   ApplyOverridesLocked(toolchain_overrides, dest);
   SaveOverrideRecordLocked(toolchain_overrides);
 }
 
@@ skipping 51 matching lines @@
       scope_to_set->SetValue(i->first, i->second, i->second.origin());
       scope_to_set->MarkUsed(i->first);
     }
   }
 
   return true;
 }
 
 bool Args::VerifyAllOverridesUsed(Err* err) const {
   base::AutoLock lock(lock_);
+  return VerifyAllOverridesUsed(all_overrides_, declared_arguments_, err);
+}
 
-  for (Scope::KeyValueMap::const_iterator i = all_overrides_.begin();
-       i != all_overrides_.end(); ++i) {
-    if (declared_arguments_.find(i->first) == declared_arguments_.end()) {
+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()) {
       // 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())
+               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 "
           "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;
+}
+
 void Args::SetSystemVarsLocked(Scope* dest) const {
+  lock_.AssertAcquired();
+
   // Host OS.
   const char* os = NULL;
 #if defined(OS_WIN)
   os = "win";
 #elif defined(OS_MACOSX)
   os = "mac";
 #elif defined(OS_LINUX)
   os = "linux";
 #else
   #error Unknown OS type.
@@ skipping 52 matching lines @@
   // Mark these variables used so the build config file can override them
   // 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());
 }
 
 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;
 }