Add not_needed function

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 "base/sys_info.h"
 #include "build/build_config.h"
+#include "tools/gn/scheduler.h"
 #include "tools/gn/string_utils.h"
 #include "tools/gn/variables.h"
 
 const char kBuildArgs_Help[] =
     R"(Build Arguments Overview
 
   Build arguments are variables passed in from outside of the build that build
   files can query to determine how the build works.
 
 How build arguments are set
@@ skipping 184 matching lines @@
     // on some other condition without dereferencing the value first.
 
     // Check whether this argument has been overridden on the toolchain level
     // and use the override instead.
     Scope::KeyValueMap::const_iterator toolchain_override =
         toolchain_overrides.find(arg.first);
     if (toolchain_override != toolchain_overrides.end()) {
       scope_to_set->SetValue(toolchain_override->first,
                              toolchain_override->second,
                              toolchain_override->second.origin());
-      scope_to_set->MarkUsed(arg.first);
+      scope_to_set->MarkUsed(arg.first, err);
       continue;
     }
 
     // Check whether this argument has been overridden and use the override
     // instead.
     Scope::KeyValueMap::const_iterator override = overrides_.find(arg.first);
     if (override != overrides_.end()) {
       scope_to_set->SetValue(override->first, override->second,
                              override->second.origin());
-      scope_to_set->MarkUsed(override->first);
+      scope_to_set->MarkUsed(override->first, err);
       continue;
     }
 
     scope_to_set->SetValue(arg.first, arg.second, arg.second.origin());
-    scope_to_set->MarkUsed(arg.first);
+    scope_to_set->MarkUsed(arg.first, err);
   }
 
   return true;
 }
 
 bool Args::VerifyAllOverridesUsed(Err* err) const {
   base::AutoLock lock(lock_);
   Scope::KeyValueMap unused_overrides(all_overrides_);
   for (const auto& map_pair : declared_arguments_per_toolchain_)
     RemoveDeclaredOverrides(map_pair.second, &unused_overrides);
@@ skipping 123 matching lines @@
       DeclaredArgumentsForToolchainLocked(dest));
   declared_arguments[variables::kHostOs] = os_val;
   declared_arguments[variables::kCurrentOs] = empty_string;
   declared_arguments[variables::kTargetOs] = empty_string;
   declared_arguments[variables::kHostCpu] = arch_val;
   declared_arguments[variables::kCurrentCpu] = empty_string;
   declared_arguments[variables::kTargetCpu] = empty_string;
 
   // Mark these variables used so the build config file can override them
   // without geting a warning about overwriting an unused variable.
-  dest->MarkUsed(variables::kHostCpu);
-  dest->MarkUsed(variables::kCurrentCpu);
-  dest->MarkUsed(variables::kTargetCpu);
-  dest->MarkUsed(variables::kHostOs);
-  dest->MarkUsed(variables::kCurrentOs);
-  dest->MarkUsed(variables::kTargetOs);
+  Err err;
+  dest->MarkUsed(variables::kHostCpu, &err);
+  dest->MarkUsed(variables::kCurrentCpu, &err);
+  dest->MarkUsed(variables::kTargetCpu, &err);
+  dest->MarkUsed(variables::kHostOs, &err);
+  dest->MarkUsed(variables::kCurrentOs, &err);
+  dest->MarkUsed(variables::kTargetOs, &err);
+  if (err.has_error())
+    g_scheduler->FailWithError(err);
 }
 
 void Args::ApplyOverridesLocked(const Scope::KeyValueMap& values,
                                 Scope* scope) const {
   lock_.AssertAcquired();
 
   const Scope::KeyValueMap& declared_arguments(
       DeclaredArgumentsForToolchainLocked(scope));
 
   // Only set a value if it has been declared.
@@ skipping 18 matching lines @@
     Scope* scope) const {
   lock_.AssertAcquired();
   return declared_arguments_per_toolchain_[scope->settings()];
 }
 
 Scope::KeyValueMap& Args::OverridesForToolchainLocked(
     Scope* scope) const {
   lock_.AssertAcquired();
   return toolchain_overrides_[scope->settings()];
 }