Setting "SubSystem" option on "Link" page for Visual Studio project.

tools/gn/visual_studio_writer.cc

 // Copyright 2016 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/visual_studio_writer.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <memory>
@@ skipping 135 matching lines @@
 }
 
 void ParseCompilerOptions(const Target* target, CompilerOptions* options) {
   for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
     ParseCompilerOptions(iter.cur().cflags(), options);
     ParseCompilerOptions(iter.cur().cflags_c(), options);
     ParseCompilerOptions(iter.cur().cflags_cc(), options);
   }
 }
 
+void ParseLinkerOptions(const std::vector<std::string>& ldflags,
+                        LinkerOptions* options) {
+  for (const std::string& flag : ldflags)
+    ParseLinkerOption(flag, options);
+}
+
+void ParseLinkerOptions(const Target* target, LinkerOptions* options) {
+  for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
+    ParseLinkerOptions(iter.cur().ldflags(), options);
+  }
+}
+
 // Returns a string piece pointing into the input string identifying the parent
 // directory path, excluding the last slash. Note that the input pointer must
 // outlive the output.
 base::StringPiece FindParentDir(const std::string* path) {
   DCHECK(path && !path->empty());
   for (int i = static_cast<int>(path->size()) - 2; i >= 0; --i) {
     if (IsSlash((*path)[i]))
       return base::StringPiece(path->data(), i);
   }
   return base::StringPiece();
@@ skipping 366 matching lines @@
       if (!options.runtime_library.empty())
         cl_compile->SubElement("RuntimeLibrary")->Text(options.runtime_library);
       if (!options.treat_warning_as_error.empty()) {
         cl_compile->SubElement("TreatWarningAsError")
             ->Text(options.treat_warning_as_error);
       }
       if (!options.warning_level.empty())
         cl_compile->SubElement("WarningLevel")->Text(options.warning_level);
     }
 
-    // We don't include resource compilation and link options as ninja files
-    // are used to generate real build.
+    std::unique_ptr<XmlElementWriter> link =
+        item_definitions->SubElement("Link");
+    {
+      LinkerOptions options;
+      ParseLinkerOptions(target, &options);
+      if (!options.subsystem.empty())
+        link->SubElement("SubSystem")->Text(options.subsystem);
+    }
+
+    // We don't include resource compilation and other link options as ninja
+    // files are used to generate real build.
   }
 
   {
     std::unique_ptr<XmlElementWriter> group = project.SubElement("ItemGroup");
     std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
 
     for (const SourceFile& file : target->sources()) {
       const char* compile_type;
       Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
       if (target->GetOutputFilesForSource(file, &tool_type, &tool_outputs)) {
@@ skipping 284 matching lines @@
   }
 }
 
 std::string VisualStudioWriter::GetNinjaTarget(const Target* target) {
   std::ostringstream ninja_target_out;
   DCHECK(!target->dependency_output_file().value().empty());
   ninja_path_output_.WriteFile(ninja_target_out,
                                target->dependency_output_file());
   return ninja_target_out.str();
 }