Support for excluding variable from forwarding via forward_variables_form.

tools/gn/scope.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/scope.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
 
 namespace {
 
 // FLags set in the mode_flags_ of a scope. If a bit is set, it applies
 // recursively to all dependent scopes.
 const unsigned kProcessingBuildConfigFlag = 1;
 const unsigned kProcessingImportFlag = 2;
 
 // Returns true if this variable name should be considered private. Private
 // values start with an underscore, and are not imported from "gni" files
 // when processing an import.
 bool IsPrivateVar(const base::StringPiece& name) {
   return name.empty() || name[0] == '_';
 }
 
 }  // namespace
 
+// Defaults to all false, which are the things least likely to cause errors.
+Scope::MergeOptions::MergeOptions()
+    : clobber_existing(false),
+      skip_private_vars(false),
+      mark_dest_used(false) {}
+
+Scope::MergeOptions::~MergeOptions() {}
 
 Scope::ProgrammaticProvider::~ProgrammaticProvider() {
   scope_->RemoveProvider(this);
 }
 
 Scope::Scope(const Settings* settings)
     : const_containing_(nullptr),
       mutable_containing_(nullptr),
       settings_(settings),
       mode_flags_(0),
@@ skipping 206 matching lines @@
 
 bool Scope::NonRecursiveMergeTo(Scope* dest,
                                 const MergeOptions& options,
                                 const ParseNode* node_for_err,
                                 const char* desc_for_err,
                                 Err* err) const {
   // Values.
   for (const auto& pair : values_) {
     if (options.skip_private_vars && IsPrivateVar(pair.first))
       continue;  // Skip this private var.
+    if (!options.excluded_values.empty() &&
+        options.excluded_values.find(pair.first.as_string()) !=
+            options.excluded_values.end()) {
+      continue;  // Skip this excluded value.
+    }
 
     const Value& new_value = pair.second.value;
     if (!options.clobber_existing) {
       const Value* existing_value = dest->GetValue(pair.first);
       if (existing_value && new_value != *existing_value) {
         // Value present in both the source and the dest.
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Value collision.",
             "This " + desc_string + " contains \"" + pair.first.as_string() +
             "\"");
@@ skipping 220 matching lines @@
 }
 
 void Scope::AddProvider(ProgrammaticProvider* p) {
   programmatic_providers_.insert(p);
 }
 
 void Scope::RemoveProvider(ProgrammaticProvider* p) {
   DCHECK(programmatic_providers_.find(p) != programmatic_providers_.end());
   programmatic_providers_.erase(p);
 }