Allow multiple set_default calls in GN.

tools/gn/scope.h

 // 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.
 
 #ifndef TOOLS_GN_SCOPE_H_
 #define TOOLS_GN_SCOPE_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 211 matching lines @@
                            const char* desc_for_err,
                            Err* err) const;
 
   // Constructs a scope that is a copy of the current one. Nested scopes will
   // be collapsed until we reach a const containing scope. Private values will
   // be included. The resulting closure will reference the const containing
   // scope as its containing scope (since we assume the const scope won't
   // change, we don't have to copy its values).
   std::unique_ptr<Scope> MakeClosure() const;
 
-  // Makes an empty scope with the given name. Returns NULL if the name is
-  // already set.
+  // Makes an empty scope with the given name. Overwrites any existing one.
   Scope* MakeTargetDefaults(const std::string& target_type);
 
   // Gets the scope associated with the given target name, or null if it hasn't
   // been set.
   const Scope* GetTargetDefaults(const std::string& target_type) const;
 
   // Filter to apply when the sources variable is assigned. May return NULL.
   const PatternList* GetSourcesAssignmentFilter() const;
   void set_sources_assignment_filter(std::unique_ptr<PatternList> f) {
     sources_assignment_filter_ = std::move(f);
@@ skipping 60 matching lines @@
   friend class ProgrammaticProvider;
 
   struct Record {
     Record() : used(false) {}
     explicit Record(const Value& v) : used(false), value(v) {}
 
     bool used;  // Set to true when the variable is used.
     Value value;
   };
 
+  typedef base::hash_map<base::StringPiece, Record, base::StringPieceHash>
+      RecordMap;
+
   void AddProvider(ProgrammaticProvider* p);
   void RemoveProvider(ProgrammaticProvider* p);
 
+  // Returns true if the two RecordMaps contain the same values (the origins
+  // of the values may be different).
+  static bool RecordMapValuesEqual(const RecordMap& a, const RecordMap& b);
+
   // Scopes can have no containing scope (both null), a mutable containing
   // scope, or a const containing scope. The reason is that when we're doing
   // a new target, we want to refer to the base_config scope which will be read
   // by multiple threads at the same time, so we REALLY want it to be const.
   // When you jsut do a nested {}, however, we sometimes want to be able to
   // change things (especially marking unused vars).
   const Scope* const_containing_;
   Scope* mutable_containing_;
 
   const Settings* settings_;
 
   // Bits set for different modes. See the flag definitions in the .cc file
   // for more.
   unsigned mode_flags_;
 
-  typedef base::hash_map<base::StringPiece, Record, base::StringPieceHash>
-      RecordMap;
   RecordMap values_;
 
   // Note that this can't use string pieces since the names are constructed from
   // Values which might be deallocated before this goes out of scope.
   typedef base::hash_map<std::string, std::unique_ptr<Scope>> NamedScopeMap;
   NamedScopeMap target_defaults_;
 
   // Null indicates not set and that we should fallback to the containing
   // scope's filter.
   std::unique_ptr<PatternList> sources_assignment_filter_;
@@ skipping 10 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_