GN threading refactor

tools/gn/command_gyp.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 <iostream>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/err.h"
 #include "tools/gn/gyp_helper.h"
 #include "tools/gn/gyp_target_writer.h"
-#include "tools/gn/item_node.h"
 #include "tools/gn/location.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
 
 namespace commands {
 
 namespace {
 
 typedef GypTargetWriter::TargetGroup TargetGroup;
 typedef std::map<Label, TargetGroup> CorrelatedTargetsMap;
 typedef std::map<SourceFile, std::vector<TargetGroup> > GroupedTargetsMap;
 typedef std::map<std::string, std::string> StringStringMap;
 
+std::vector<const BuilderRecord*> GetAllResolvedTargetRecords(
+    const Builder* builder) {
+  std::vector<const BuilderRecord*> all = builder->GetAllRecords();
+  std::vector<const BuilderRecord*> result;
+  result.reserve(all.size());
+  for (size_t i = 0; i < all.size(); i++) {
+    if (all[i]->type() == BuilderRecord::ITEM_TARGET &&
+        all[i]->should_generate() &&
+        all[i]->item())
+      result.push_back(all[i]);
+  }
+  return result;
+}
+
 // Groups targets sharing the same label between debug and release.
-void CorrelateTargets(const std::vector<const Target*>& debug_targets,
-                      const std::vector<const Target*>& release_targets,
+void CorrelateTargets(const std::vector<const BuilderRecord*>& debug_targets,
+                      const std::vector<const BuilderRecord*>& release_targets,
                       CorrelatedTargetsMap* correlated) {
   for (size_t i = 0; i < debug_targets.size(); i++) {
-    const Target* target = debug_targets[i];
-    (*correlated)[target->label()].debug = target;
+    const BuilderRecord* record = debug_targets[i];
+    (*correlated)[record->label()].debug = record;
   }
   for (size_t i = 0; i < release_targets.size(); i++) {
-    const Target* target = release_targets[i];
-    (*correlated)[target->label()].release = target;
+    const BuilderRecord* record = release_targets[i];
+    (*correlated)[record->label()].release = record;
   }
 }
 
 // Verifies that both debug and release variants match. They can differ only
 // by flags.
 bool EnsureTargetsMatch(const TargetGroup& group, Err* err) {
   // Check that both debug and release made this target.
   if (!group.debug || !group.release) {
-    const Target* non_null_one = group.debug ? group.debug : group.release;
+    const BuilderRecord* non_null_one =
+        group.debug ? group.debug : group.release;
     *err = Err(Location(), "The debug and release builds did not both generate "
         "a target with the name\n" +
         non_null_one->label().GetUserVisibleName(true));
     return false;
   }
 
+  const Target* debug_target = group.debug->item()->AsTarget();
+  const Target* release_target = group.release->item()->AsTarget();
+
   // Check the flags that determine if and where we write the GYP file.
-  if (group.debug->item_node()->should_generate() !=
-          group.release->item_node()->should_generate() ||
-      group.debug->external() != group.release->external() ||
-      group.debug->gyp_file() != group.release->gyp_file()) {
+  if (group.debug->should_generate() != group.release->should_generate() ||
+      debug_target->external() != release_target->external() ||
+      debug_target->gyp_file() != release_target->gyp_file()) {
     *err = Err(Location(), "The metadata for the target\n" +
         group.debug->label().GetUserVisibleName(true) +
         "\ndoesn't match between the debug and release builds.");
     return false;
   }
 
   // Check that the sources match.
-  if (group.debug->sources().size() != group.release->sources().size()) {
+  if (debug_target->sources().size() != release_target->sources().size()) {
     *err = Err(Location(), "The source file count for the target\n" +
         group.debug->label().GetUserVisibleName(true) +
         "\ndoesn't have the same number of files between the debug and "
         "release builds.");
     return false;
   }
-  for (size_t i = 0; i < group.debug->sources().size(); i++) {
-    if (group.debug->sources()[i] != group.release->sources()[i]) {
+  for (size_t i = 0; i < debug_target->sources().size(); i++) {
+    if (debug_target->sources()[i] != release_target->sources()[i]) {
       *err = Err(Location(), "The debug and release version of the target \n" +
           group.debug->label().GetUserVisibleName(true) +
           "\ndon't agree on the file\n" +
-          group.debug->sources()[i].value());
+          debug_target->sources()[i].value());
       return false;
     }
   }
 
   // Check that the deps match.
-  if (group.debug->deps().size() != group.release->deps().size()) {
+  if (debug_target->deps().size() != release_target->deps().size()) {
     *err = Err(Location(), "The source file count for the target\n" +
         group.debug->label().GetUserVisibleName(true) +
         "\ndoesn't have the same number of deps between the debug and "
         "release builds.");
     return false;
   }
-  for (size_t i = 0; i < group.debug->deps().size(); i++) {
-    if (group.debug->deps()[i].label != group.release->deps()[i].label) {
+  for (size_t i = 0; i < debug_target->deps().size(); i++) {
+    if (debug_target->deps()[i].label != release_target->deps()[i].label) {
       *err = Err(Location(), "The debug and release version of the target \n" +
           group.debug->label().GetUserVisibleName(true) +
           "\ndon't agree on the dep\n" +
-          group.debug->deps()[i].label.GetUserVisibleName(true));
+          debug_target->deps()[i].label.GetUserVisibleName(true));
       return false;
     }
   }
-
   return true;
 }
 
 // Python uses shlex.split, which we partially emulate here.
 //
 // Advances to the next "word" in a GYP_DEFINES entry. This is something
 // separated by whitespace or '='. We allow backslash escaping and quoting.
 // The return value will be the index into the array immediately following the
 // word, and the contents of the word will be placed into |*word|.
 size_t GetNextGypDefinesWord(const std::string& defines,
@@ skipping 87 matching lines @@
   }
 
   // Windows SDK path. GYP and the GN build use the same name.
   static const char kWinSdkPath[] = "windows_sdk_path";
   if (!gyp_defines[kWinSdkPath].empty())
     result[kWinSdkPath] = Value(NULL, gyp_defines[kWinSdkPath]);
 
   return result;
 }
 
-// Returns the number of targets, number of GYP files.
-std::pair<int, int> WriteGypFiles(
-    const BuildSettings& debug_settings,
-    const BuildSettings& release_settings,
-    Err* err) {
+// Returns the (number of targets, number of GYP files).
+std::pair<int, int> WriteGypFiles(CommonSetup* debug_setup,
+                                  CommonSetup* release_setup,
+                                  Err* err) {
   // Group all targets by output GYP file name.
-  std::vector<const Target*> debug_targets;
-  std::vector<const Target*> release_targets;
-  debug_settings.target_manager().GetAllTargets(&debug_targets);
-  release_settings.target_manager().GetAllTargets(&release_targets);
+  std::vector<const BuilderRecord*> debug_targets =
+      GetAllResolvedTargetRecords(debug_setup->builder());
+  std::vector<const BuilderRecord*> release_targets =
+      GetAllResolvedTargetRecords(release_setup->builder());
 
   // Match up the debug and release version of each target by label.
   CorrelatedTargetsMap correlated;
   CorrelateTargets(debug_targets, release_targets, &correlated);
 
   GypHelper helper;
   GroupedTargetsMap grouped_targets;
   int target_count = 0;
   for (CorrelatedTargetsMap::iterator i = correlated.begin();
        i != correlated.end(); ++i) {
     const TargetGroup& group = i->second;
-    if (!group.debug->item_node()->should_generate())
+    if (!group.debug->should_generate())
       continue;  // Skip non-generated ones.
-    if (group.debug->external())
+    if (group.debug->item()->AsTarget()->external())
       continue;  // Skip external ones.
-    if (group.debug->gyp_file().is_null())
+    if (group.debug->item()->AsTarget()->gyp_file().is_null())
       continue;  // Skip ones without GYP files.
 
     if (!EnsureTargetsMatch(group, err))
       return std::make_pair(0, 0);
 
     target_count++;
-    grouped_targets[helper.GetGypFileForTarget(group.debug, err)].push_back(
-        group);
+    grouped_targets[
+            helper.GetGypFileForTarget(group.debug->item()->AsTarget(), err)]
+        .push_back(group);
     if (err->has_error())
       return std::make_pair(0, 0);
   }
 
   // Write each GYP file.
   for (GroupedTargetsMap::iterator i = grouped_targets.begin();
        i != grouped_targets.end(); ++i) {
     GypTargetWriter::WriteFile(i->first, i->second, err);
     if (err->has_error())
       return std::make_pair(0, 0);
@@ skipping 92 matching lines @@
                 "gn_release.tmp/"));
 
   // Run both debug and release builds in parallel.
   setup_release->RunPreMessageLoop();
   if (!setup_debug->Run())
     return 1;
   if (!setup_release->RunPostMessageLoop())
     return 1;
 
   Err err;
-  std::pair<int, int> counts = WriteGypFiles(setup_debug->build_settings(),
-                                             setup_release->build_settings(),
-                                             &err);
+  std::pair<int, int> counts = WriteGypFiles(setup_debug, setup_release, &err);
   if (err.has_error()) {
     err.PrintToStdout();
     return 1;
   }
 
   // Timing info.
   base::TimeTicks end_time = base::TimeTicks::Now();
   if (!cmdline->HasSwitch(kSwitchQuiet)) {
     OutputString("Done. ", DECORATION_GREEN);
 
     std::string stats = "Wrote " +
         base::IntToString(counts.first) + " targets to " +
         base::IntToString(counts.second) + " GYP files read from " +
         base::IntToString(
             setup_debug->scheduler().input_file_manager()->GetInputFileCount())
         + " GN files in " +
         base::IntToString((end_time - begin_time).InMilliseconds()) + "ms\n";
 
     OutputString(stats);
   }
 
   return 0;
 }
 
 }  // namespace commands