Display override values in GN args help.

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/string_utils.h"
 #include "tools/gn/variables.h"
@@ skipping 66 matching lines @@
        override != overrides->end();) {
     if (declared_arguments.find(override->first) == declared_arguments.end())
       ++override;
     else
       overrides->erase(override++);
   }
 }
 
 }  // namespace
 
+Args::ValueWithOverride::ValueWithOverride()
+    : default_value(),
+      has_override(false),
+      override_value() {
+}
+
+Args::ValueWithOverride::ValueWithOverride(const Value& def_val)
+    : default_value(def_val),
+      has_override(false),
+      override_value() {
+}
+
+Args::ValueWithOverride::~ValueWithOverride() {
+}
+
 Args::Args() {
 }
 
 Args::Args(const Args& other)
     : overrides_(other.overrides_),
       all_overrides_(other.all_overrides_),
       declared_arguments_per_toolchain_(
           other.declared_arguments_per_toolchain_),
       toolchain_overrides_(other.toolchain_overrides_) {
 }
@@ skipping 20 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 nullptr;
   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);
 
   // Apply overrides for already declared args.
   // (i.e. the system vars we set above)
   ApplyOverridesLocked(overrides_, dest);
   ApplyOverridesLocked(toolchain_overrides, dest);
@@ skipping 105 matching lines @@
       candidates.push_back(declared_arg.first);
   }
   base::StringPiece suggestion = SpellcheckString(name, candidates);
   if (!suggestion.empty())
     err_help = "Did you mean \"" + suggestion + "\"?\n\n" + err_help;
 
   *err = Err(value.origin(), "Build argument has no effect.", err_help);
   return false;
 }
 
-void Args::MergeDeclaredArguments(Scope::KeyValueMap* dest) const {
+Args::ValueWithOverrideMap Args::GetAllArguments() const {
+  ValueWithOverrideMap result;
+
   base::AutoLock lock(lock_);
+
+  // Default values.
   for (const auto& map_pair : declared_arguments_per_toolchain_) {
     for (const auto& arg : map_pair.second)
-      (*dest)[arg.first] = arg.second;
+      result.insert(std::make_pair(arg.first, ValueWithOverride(arg.second)));
   }
+
+  // Merge in overrides.
+  for (const auto& over : overrides_) {
+    auto found = result.find(over.first);
+    if (found != result.end()) {
+      found->second.has_override = true;
+      found->second.override_value = over.second;
+    }
+  }
+
+  return result;
 }
 
 void Args::SetSystemVarsLocked(Scope* dest) const {
   lock_.AssertAcquired();
 
   // Host OS.
   const char* os = nullptr;
 #if defined(OS_WIN)
   os = "win";
 #elif defined(OS_MACOSX)
@@ skipping 101 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()];
 }