GN: Separately track labels and origins for lists of stuff

tools/gn/gyp_binary_target_writer.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/gyp_binary_target_writer.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 79 matching lines @@
       }
     }
   }
   return "'2'";  // Default value.
 }
 
 // Finds all values from the given getter from all configs in the given list,
 // and adds them to the given result vector.
 template<typename T>
 void FillConfigListValues(
-    const std::vector<const Config*>& configs,
+    const LabelConfigVector& configs,
     const std::vector<T>& (ConfigValues::* getter)() const,
     std::vector<T>* result) {
   for (size_t config_i = 0; config_i < configs.size(); config_i++) {
     const std::vector<T>& values =
-        (configs[config_i]->config_values().*getter)();
+        (configs[config_i].ptr->config_values().*getter)();
     for (size_t val_i = 0; val_i < values.size(); val_i++)
       result->push_back(values[val_i]);
   }
 }
 
 const int kExtraIndent = 2;
 
 }  // namespace
 
 GypBinaryTargetWriter::Flags::Flags() {}
@@ skipping 234 matching lines @@
   for (size_t i = 0; i < sources.size(); i++) {
     const SourceFile& input_file = sources[i];
     Indent(indent + kExtraIndent) << "'" << helper_.GetFileReference(input_file)
                                   << "',\n";
   }
 
   Indent(indent) << "],\n";
 }
 
 void GypBinaryTargetWriter::WriteDeps(const Target* target, int indent) {
-  const std::vector<const Target*>& deps = target->deps();
+  const LabelTargetVector& deps = target->deps();
   if (deps.empty())
     return;
 
   EscapeOptions escape_options;
   escape_options.mode = ESCAPE_JSON;
 
   Indent(indent) << "'dependencies': [\n";
   for (size_t i = 0; i < deps.size(); i++) {
     Indent(indent + kExtraIndent) << "'";
-    EscapeStringToStream(out_, helper_.GetFullRefForTarget(deps[i]),
+    EscapeStringToStream(out_, helper_.GetFullRefForTarget(deps[i].ptr),
                          escape_options);
     out_ << "',\n";
   }
   Indent(indent) << "],\n";
 }
 
 void GypBinaryTargetWriter::WriteIncludeDirs(const Flags& flags, int indent) {
   if (flags.include_dirs.empty())
     return;
 
@@ skipping 73 matching lines @@
     ret.lib_dirs.push_back(all_lib_dirs[i]);
 
   const OrderedSet<std::string> all_libs = target->all_libs();
   for (size_t i = 0; i < all_libs.size(); i++)
     ret.libs.push_back(all_libs[i]);
 
   return ret;
 }
 
 GypBinaryTargetWriter::Flags GypBinaryTargetWriter::FlagsFromConfigList(
-    const std::vector<const Config*>& configs) const {
+    const LabelConfigVector& configs) const {
   Flags ret;
 
   #define EXTRACT(type, name) \
       FillConfigListValues<type>(configs, &ConfigValues::name, &ret.name);
 
   EXTRACT(std::string, defines);
   EXTRACT(SourceDir,   include_dirs);
   EXTRACT(std::string, cflags);
   EXTRACT(std::string, cflags_c);
   EXTRACT(std::string, cflags_cc);
   EXTRACT(std::string, cflags_objc);
   EXTRACT(std::string, cflags_objcc);
   EXTRACT(std::string, ldflags);
   EXTRACT(SourceDir,   lib_dirs);
   EXTRACT(std::string, libs);
 
   #undef EXTRACT
 
   return ret;
 }