[GN] Add deployment target in generated project.

tools/gn/xcode_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/xcode_writer.h"
 
 #include <iomanip>
 #include <map>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/args.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/filesystem_utils.h"
+#include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/target.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 #include "tools/gn/xcode_object.h"
 
 namespace {
 
-XcodeWriter::TargetOsType GetTargetOs(const Args& args) {
-  const Value* target_os_value = args.GetArgOverride(variables::kTargetOs);
-  if (target_os_value) {
-    if (target_os_value->type() == Value::STRING) {
-      if (target_os_value->string_value() == "ios")
-        return XcodeWriter::WRITER_TARGET_OS_IOS;
+bool GetTargetOs(const Scope* scope, std::string* target_os, Err* err) {
+  const char* variable_names[] = {variables::kTargetOs, variables::kHostOs};
+  for (size_t i = 0; i < arraysize(variable_names); ++i) {
+    const Value* value = scope->GetValue(variable_names[i]);
+    if (value && value->type() == Value::STRING &&
+        !value->string_value().empty()) {
+      target_os->assign(value->string_value());
+      return true;
     }
   }
-  return XcodeWriter::WRITER_TARGET_OS_MACOS;
+  *err = Err(nullptr, "cannot determine target_os");
+  return false;
 }
 
-std::string GetArchs(const Args& args) {
-  const Value* target_cpu_value = args.GetArgOverride(variables::kTargetCpu);
-  if (target_cpu_value) {
-    if (target_cpu_value->type() == Value::STRING) {
-      if (target_cpu_value->string_value() == "x86")
-        return "i386";
-      if (target_cpu_value->string_value() == "x64")
-        return "x86_64";
-      if (target_cpu_value->string_value() == "arm")
-        return "armv7";
-      if (target_cpu_value->string_value() == "armv7")
-        return "armv7";
-      if (target_cpu_value->string_value() == "arm64")
-        return "armv64";
+bool GetTargetCpu(const Scope* scope, std::string* target_cpu, Err* err) {
+  const char* variable_names[] = {variables::kTargetCpu, variables::kHostCpu};
+  for (size_t i = 0; i < arraysize(variable_names); ++i) {
+    const Value* value = scope->GetValue(variable_names[i]);
+    if (value && value->type() == Value::STRING &&
+        !value->string_value().empty()) {
+      if (value->string_value() == "x86") {
+        target_cpu->assign("i386");
+        return true;
+      }
+      if (value->string_value() == "x64") {
+        target_cpu->assign("x86_64");
+        return true;
+      }
+      if (value->string_value() == "arm") {
+        target_cpu->assign("armv7");
+        return true;
+      }
+      if (value->string_value() == "arm64") {
+        target_cpu->assign("arm64");
+        return true;
+      }
     }
   }
-  return "x86_64";
+  *err = Err(nullptr, "cannot determine target_cpu");
+  return false;
+}
+
+bool GetDeploymentTarget(const Scope* scope,
+                         const char* variable,
+                         std::string* deployment_target,
+                         Err* err) {
+  const Value* value = scope->GetValue(variable);
+  if (!value || value->type() != Value::STRING) {
+    *err = Err(nullptr, "cannot determine deployment target");
+    return false;
+  }
+
+  deployment_target->assign(value->string_value());
+  return true;
 }
 
 std::string GetBuildScript(const std::string& target_name,
                            const std::string& build_path,
                            const std::string& ninja_extra_args) {
   std::stringstream script;
   script << "echo note: \"Compile and copy " << target_name << " via ninja\"\n"
          << "exec ";
   if (!build_path.empty())
     script << "env PATH=\"" << build_path << "\" ";
@@ skipping 68 matching lines @@
 }  // namespace
 
 // static
 bool XcodeWriter::RunAndWriteFiles(const std::string& workspace_name,
                                    const std::string& root_target_name,
                                    const std::string& ninja_extra_args,
                                    const std::string& dir_filters_string,
                                    const BuildSettings* build_settings,
                                    Builder* builder,
                                    Err* err) {
-  const XcodeWriter::TargetOsType target_os =
-      GetTargetOs(build_settings->build_args());
-
   PBXAttributes attributes;
-  switch (target_os) {
-    case XcodeWriter::WRITER_TARGET_OS_IOS:
-      attributes["SDKROOT"] = "iphoneos";
-      attributes["TARGETED_DEVICE_FAMILY"] = "1,2";
-      break;
-    case XcodeWriter::WRITER_TARGET_OS_MACOS:
-      attributes["ARCHS"] = GetArchs(build_settings->build_args());
-      attributes["SDKROOT"] = "macosx10.11";
-      break;
-  }
+  if (!GetProjectsAttributes(build_settings, &attributes, err))
+    return false;
 
   const std::string source_path =
       base::FilePath::FromUTF8Unsafe(
           RebasePath("//", build_settings->build_dir()))
           .StripTrailingSeparators()
           .AsUTF8Unsafe();
 
   std::string config_name = build_settings->build_dir()
                                 .Resolve(base::FilePath())
                                 .StripTrailingSeparators()
                                 .BaseName()
                                 .AsUTF8Unsafe();
   DCHECK(!config_name.empty());
 
   std::string::size_type separator = config_name.find('-');
   if (separator != std::string::npos)
     config_name = config_name.substr(0, separator);
 
   std::vector<const Target*> targets;
   std::vector<const Target*> all_targets = builder->GetAllResolvedTargets();
   if (!XcodeWriter::FilterTargets(build_settings, all_targets,
                                   dir_filters_string, &targets, err)) {
     return false;
   }
 
   XcodeWriter workspace(workspace_name);
   workspace.CreateProductsProject(targets, attributes, source_path, config_name,
                                   root_target_name, ninja_extra_args,
-                                  build_settings, target_os);
+                                  build_settings);
 
   workspace.CreateSourcesProject(all_targets, build_settings->build_dir(),
-                                 attributes, source_path, config_name,
-                                 target_os);
+                                 attributes, source_path, config_name);
 
   return workspace.WriteFiles(build_settings, err);
 }
 
 XcodeWriter::XcodeWriter(const std::string& name) : name_(name) {
   if (name_.empty())
     name_.assign("all");
 }
 
 XcodeWriter::~XcodeWriter() {}
 
 // static
+bool XcodeWriter::GetProjectsAttributes(const BuildSettings* build_settings,
+                                        PBXAttributes* attributes,
+                                        Err* err) {
+  Settings* null_settings = nullptr;

[sdefresne, 2016/06/14 17:45:10]

I'm not sure about this code. Previously the code used
build_settings->build_args() which was incorrect, so now it uses the
declared_args default value or their overrides but I still have to code some of
the logic that sets target_cpu to host_cpu if target_cpu is not in build_args.

I'm also unsure about getting global variables "ios_deployment_target" and
"mac_deployment_target". It works with current Chromium build/config files but
do we really want to hard-code this? Should I instead leave all the key/value
pairs construction completely outside of gn binary and ask the user to pass them
on the command-line when passing --ide=xcode? If so, should I provide a script
that invokes "gn gen" with the values found in $output_dir/args.gn and
build/config/{ios,mac}/{ios,mac}_sdk.gni?

WDYT?

+  Scope global_scope(null_settings);
+  Scope::KeyValueMap declared_arguments;
+  build_settings->build_args().MergeDeclaredArguments(&declared_arguments);
+  for (const auto& pair : declared_arguments) {
+    global_scope.SetValue(pair.first, pair.second, nullptr);
+  }
+  build_settings->build_args().SetupRootScope(&global_scope,
+                                              Scope::KeyValueMap());
+
+  std::string target_os;
+  if (!GetTargetOs(&global_scope, &target_os, err))
+    return false;
+
+  std::string target_cpu;
+  if (!GetTargetCpu(&global_scope, &target_cpu, err))
+    return false;
+
+  if (target_os == "ios") {
+    std::string deployment_target;
+    if (!GetDeploymentTarget(&global_scope, "ios_deployment_target",
+                             &deployment_target, err))
+      return false;
+
+    attributes->insert(std::make_pair("SDKROOT", "iphoneos"));
+    attributes->insert(std::make_pair("TARGETED_DEVICE_FAMILY", "1,2"));
+    attributes->insert(
+        std::make_pair("IPHONEOS_DEPLOYMENT_TARGET", deployment_target));
+  } else {
+    std::string deployment_target;
+    if (!GetDeploymentTarget(&global_scope, "mac_deployment_target",
+                             &deployment_target, err))
+      return false;
+
+    attributes->insert(std::make_pair("ARCHS", target_cpu));
+    attributes->insert(std::make_pair("SDKROOT", "macosx"));
+    attributes->insert(
+        std::make_pair("MACOSX_DEPLOYMENT_TARGET", deployment_target));
+  }
+
+  return true;
+}
+
+// static
 bool XcodeWriter::FilterTargets(const BuildSettings* build_settings,
                                 const std::vector<const Target*>& all_targets,
                                 const std::string& dir_filters_string,
                                 std::vector<const Target*>* targets,
                                 Err* err) {
   // Filter targets according to the semicolon-delimited list of label patterns,
   // if defined, first.
   targets->reserve(all_targets.size());
   if (dir_filters_string.empty()) {
     *targets = all_targets;
@@ skipping 40 matching lines @@
   return true;
 }
 
 void XcodeWriter::CreateProductsProject(
     const std::vector<const Target*>& targets,
     const PBXAttributes& attributes,
     const std::string& source_path,
     const std::string& config_name,
     const std::string& root_target,
     const std::string& ninja_extra_args,
-    const BuildSettings* build_settings,
-    TargetOsType target_os) {
+    const BuildSettings* build_settings) {
   std::unique_ptr<PBXProject> main_project(
       new PBXProject("products", config_name, source_path, attributes));
 
   std::string build_path;
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   env->GetVar("PATH", &build_path);
 
   main_project->AddAggregateTarget(
       "All", GetBuildScript(root_target, build_path, ninja_extra_args));
 
+  const auto iter = attributes.find("SDKROOT");
+  const bool skip_executable_targets =
+      iter != attributes.end() && iter->second == "iphoneos";
+
   for (const Target* target : targets) {
     switch (target->output_type()) {
       case Target::EXECUTABLE:
-        if (target_os == XcodeWriter::WRITER_TARGET_OS_IOS)
+        if (skip_executable_targets)
           continue;
 
         main_project->AddNativeTarget(
             target->label().name(), "compiled.mach-o.executable",
             target->output_name().empty() ? target->label().name()
                                           : target->output_name(),
             "com.apple.product-type.tool",
             GetBuildScript(target->label().name(), build_path,
                            ninja_extra_args));
         break;
@@ skipping 19 matching lines @@
   }
 
   projects_.push_back(std::move(main_project));
 }
 
 void XcodeWriter::CreateSourcesProject(
     const std::vector<const Target*>& targets,
     const SourceDir& root_build_dir,
     const PBXAttributes& attributes,
     const std::string& source_path,
-    const std::string& config_name,
-    TargetOsType target_os) {
+    const std::string& config_name) {
   std::vector<SourceFile> sources;
   for (const Target* target : targets) {
     if (!target->settings()->is_default())
       continue;
 
     for (const SourceFile& source : target->sources()) {
       if (source.is_system_absolute())
         continue;
 
       if (IsStringInOutputDir(root_build_dir, source.value()))
@@ skipping 89 matching lines @@
     for (const auto& object : pair.second) {
       object->Print(out, 2);
     }
     out << "/* End " << ToString(pair.first) << " section */\n";
   }
 
   out << "\t};\n"
       << "\trootObject = " << project->Reference() << ";\n"
       << "}\n";
 }