Work on GN iOS GYP generation.

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 "base/strings/string_util.h"
@@ skipping 75 matching lines @@
       // The arch was passed as one GN string value, e.g. "-arch i386". Return
       // the stuff following the space and delete the item.
       std::string ret = cur.substr(6);
       cflags->erase(cflags->begin() + i);
       return ret;
     }
   }
   return std::string();
 }
 
+// Searches for -miphoneos-version-min, returns the resulting value, and
+// removes it from the list. Returns the empty string if it's not found.
+std::string GetIPhoneVersionMin(std::vector<std::string>* cflags) {
+  // Searches for the "-arch" option and returns the corresponding GYP value.
+  const char prefix[] = "-miphoneos-version-min=";
+  for (size_t i = 0; i < cflags->size(); i++) {
+    const std::string& cur = (*cflags)[i];
+    if (StartsWithASCII(cur, prefix, true)) {
+      std::string result = cur.substr(arraysize(prefix) - 1);
+      cflags->erase(cflags->begin() + i);
+      return result;
+    }
+  }
+  return std::string();
+}
+
 // 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 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].ptr->config_values().*getter)();
     for (size_t val_i = 0; val_i < values.size(); val_i++)
       result->push_back(values[val_i]);
   }
 }
 
+bool IsClang(const Target* target) {
+  const Value* is_clang =
+      target->settings()->base_config()->GetValue("is_clang");
+  return is_clang && is_clang->type() == Value::BOOLEAN &&
+      is_clang->boolean_value();
+}
+
+bool IsIOS(const Target* target) {
+  const Value* is_ios = target->settings()->base_config()->GetValue("is_ios");
+  return is_ios && is_ios->type() == Value::BOOLEAN && is_ios->boolean_value();
+}
+
+// Returns true if the current target is an iOS simulator build.
+bool IsIOSSimulator(const std::vector<std::string>& cflags) {
+  // Search for the sysroot flag. We expect one flag to be the
+  // switch, and the following one to be the value.

[Nico, 2014/02/05 04:19:35]

I think both -isysroot foo and -isysroot=foo might be valid, not sure though.

+  const char sysroot[] = "-isysroot";
+  for (size_t i = 0; i < cflags.size(); i++) {
+    const std::string& cur = cflags[i];
+    if (cur == sysroot) {
+      if (i == cflags.size() - 1)
+        return false;  // No following value.
+
+      // The argument is a file path, we check the prefix of the file name.
+      base::FilePath path(UTF8ToFilePath(cflags[i + 1]));
+      std::string path_file_part = FilePathToUTF8(path.BaseName());
+      return StartsWithASCII(path_file_part, "iphonesimulator", false);
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 GypBinaryTargetWriter::Flags::Flags() {}
 GypBinaryTargetWriter::Flags::~Flags() {}
 
 GypBinaryTargetWriter::GypBinaryTargetWriter(const TargetGroup& group,
                                              const Toolchain* debug_toolchain,
                                              const SourceDir& gyp_dir,
                                              std::ostream& out)
     : GypTargetWriter(group.get()->item()->AsTarget(), debug_toolchain,
@@ skipping 254 matching lines @@
                   indent + kExtraIndent * 2);
 
   // ...LD flags.
   // TODO(brettw) EnableUAC defaults to on and needs to be set. Also
   // UACExecutionLevel and UACUIAccess depends on that and defaults to 0/false.
   WriteNamedArray("AdditionalOptions", flags.ldflags, 14);
   Indent(indent + kExtraIndent) << "},\n";
   Indent(indent) << "},\n";
 }
 
-void GypBinaryTargetWriter::WriteMacFlags(Flags& flags, int indent) {
+void GypBinaryTargetWriter::WriteMacFlags(const Target* target,
+                                          Flags& flags,
+                                          int indent) {
   WriteNamedArray("defines", flags.defines, indent);
   WriteIncludeDirs(flags, indent);
 
   // Libraries and library directories.
   EscapeOptions escape_options;
   escape_options.mode = ESCAPE_JSON;
   if (!flags.lib_dirs.empty()) {
     Indent(indent + kExtraIndent) << "'library_dirs': [";
     for (size_t i = 0; i < flags.lib_dirs.size(); i++) {
       out_ << " '";
@@ skipping 11 matching lines @@
       out_ << " '-l";
       EscapeStringToStream(out_, flags.libs[i], escape_options);
       out_ << "',";
     }
     out_ << " ],\n";
     Indent(indent) << "},\n";
   }
 
   Indent(indent) << "'xcode_settings': {\n";
 
-  // Architecture. GYP uses this to write the -arch flag passed to the
-  // compiler, it doesn't look at our -arch flag. So we need to specify it in
-  // this special var and not in the cflags to avoid duplicates or conflicts.
+  // Architecture. GYP reads this value and uses it to generate the -arch
+  // flag, so we always want to remove it from the cflags (which is a side
+  // effect of what GetMacArch does), even in cases where we don't use the
+  // value (in the iOS arm below).
   std::string arch = GetMacArch(&flags.cflags);
-  if (arch == "i386")
-    Indent(indent + kExtraIndent) << "'ARCHS': [ 'i386' ],\n";
-  else if (arch == "x86_64")
-    Indent(indent + kExtraIndent) << "'ARCHS': [ 'x86_64' ],\n";
+  if (IsIOS(target)) {
+    // When writing an iOS "target" (not host) target, we set VALID_ARCHS
+    // instead of ARCHS and always use this hardcoded value. This matches the
+    // GYP build.
+    Indent(indent + kExtraIndent) << "'VALID_ARCHS': 'armv7 i386',\n";
+
+    // Tell XCode to target both iPhone and iPad. GN has no such concept.
+    Indent(indent + kExtraIndent) << "'TARGETED_DEVICE_FAMILY': '1,2',\n";

[Nico, 2014/02/05 04:19:35]

Hm, hardcoding this stuff in the gn binary seems somewhat unfortunate.

[brettw, 2014/02/05 04:29:30]

Yeah. Is there a command line option this maps to? I'm currently under the
impression that this just tells something to Xcode which possibly writes this
into some file. If there's some meaningful way to express this in the pure GN or
Ninja build, I can write a converted, but I didn't see anything that
corresponded.

[Nico, 2014/02/05 04:55:27]

I think this is written into the UIDeviceFamily plist key in the resulting app
bundle; it doesn't map to a flag.

Eventually, GN or something it calls will have to have a concept for this (when
it does bundling and writes Info.plist files), so maybe invent a name for it and
set it in a gni file and convert that thing to TARGETED_DEVICE_FAMILY?

On the other hand, it's unlikely to change for chrome/ios.

+
+    if (IsIOSSimulator(flags.cflags)) {
+      Indent(indent + kExtraIndent) << "'SDKROOT': 'iphonesimulator',\n";
+    } else {
+      Indent(indent + kExtraIndent) << "'SDKROOT': 'iphoneos',\n";
+      std::string min_ver = GetIPhoneVersionMin(&flags.cflags);
+      if (!min_ver.empty())
+        Indent(indent + kExtraIndent) << "'IPHONEOS_DEPLOYMENT_TARGET': '',\n";
+    }
+  } else {
+    // When doing regular Mac and "host" iOS (which look like regular Mac)
+    // builds, we can set the ARCHS value to what's specified in the build.
+    if (arch == "i386")
+      Indent(indent + kExtraIndent) << "'ARCHS': [ 'i386' ],\n";
+    else if (arch == "x86_64")
+      Indent(indent + kExtraIndent) << "'ARCHS': [ 'x86_64' ],\n";

[Nico, 2014/02/05 04:19:36]

remoting sets ARCHS to both i386, x86_64 I think (because it's a "preferences
pane plugin", meaning it's loaded into the "system preferences" process, and
that can be either 32 or 64 bit depending on OS X version.

[brettw, 2014/02/05 04:29:30]

Okay, we'll have to deal with that when it comes up, probably starting with how
to express this in the pure GN build.

[Nico, 2014/02/05 04:55:27]

The commit message on how this is done in gyp/ninja is fairly detailed:
https://code.google.com/p/gyp/source/detail?r=1692

[brettw, 2014/02/05 06:18:53]

I *think* the way to do this in GN would be to just make a "fat" mac toolchain
and everything should work fine. The main issue would be to find the best way to
invoke this (like maybe have a target in the default toolchain with the name
"remoting" that references the one in the other toolchain and copies the result
to the main build dir).

+  }
 
   // C/C++ flags.
   if (!flags.cflags.empty() || !flags.cflags_c.empty() ||
       !flags.cflags_objc.empty()) {
     Indent(indent + kExtraIndent) << "'OTHER_CFLAGS': [";
     WriteArrayValues(out_, flags.cflags);
     WriteArrayValues(out_, flags.cflags_c);
     WriteArrayValues(out_, flags.cflags_objc);
     out_ << " ],\n";
   }
   if (!flags.cflags.empty() || !flags.cflags_cc.empty() ||
       !flags.cflags_objcc.empty()) {
     Indent(indent + kExtraIndent) << "'OTHER_CPLUSPLUSFLAGS': [";
     WriteArrayValues(out_, flags.cflags);
     WriteArrayValues(out_, flags.cflags_cc);
     WriteArrayValues(out_, flags.cflags_objcc);
     out_ << " ],\n";
   }
 
   // Ld flags. Don't write these for static libraries. Otherwise, they'll be
   // passed to the library tool which doesn't expect it (the toolchain does
   // not use ldflags so these are ignored in the normal build).
-  if (target_->output_type() != Target::STATIC_LIBRARY)
+  if (target->output_type() != Target::STATIC_LIBRARY)
     WriteNamedArray("OTHER_LDFLAGS", flags.ldflags, indent + kExtraIndent);
 
   // Write the compiler that XCode should use. When we're using clang, we want
   // the custom one, otherwise don't add this and the default compiler will be
   // used.
   //
   // TODO(brettw) this is a hack. We could add a way for the GN build to set
   // these values but as far as I can see this is the only use for them, so
   // currently we manually check the build config's is_clang value.
-  const Value* is_clang =
-      target_->settings()->base_config()->GetValue("is_clang");
-  if (is_clang && is_clang->type() == Value::BOOLEAN &&
-      is_clang->boolean_value()) {
+  if (IsClang(target)) {
     base::FilePath clang_path =
         target_->settings()->build_settings()->GetFullPath(SourceFile(
             "//third_party/llvm-build/Release+Asserts/bin/clang"));
     base::FilePath clang_pp_path =
         target_->settings()->build_settings()->GetFullPath(SourceFile(
             "//third_party/llvm-build/Release+Asserts/bin/clang++"));
 
     Indent(indent + kExtraIndent)
         << "'CC': '" << FilePathToUTF8(clang_path) << "',\n";
     Indent(indent + kExtraIndent)
@@ skipping 55 matching lines @@
   if (host) {
     // Write out the first part of the conditional.
     Indent(indent) << kToolsetTargetCondition;
     extra_indent = kExtraIndent;
   }
 
   // Always write the target flags (may or may not be inside a target
   // conditional).
   {
     Flags flags(FlagsFromTarget(target->item()->AsTarget()));
-    WriteMacFlags(flags, indent + extra_indent);
+    WriteMacFlags(target->item()->AsTarget(), flags, indent + extra_indent);
   }
 
   // Now optionally write the host conditional arm.
   if (host) {
     Indent(indent) << kToolsetTargetElse;
     Flags flags(FlagsFromTarget(host->item()->AsTarget()));
-    WriteMacFlags(flags, indent + kExtraIndent);
+    WriteMacFlags(host->item()->AsTarget(), flags, indent + kExtraIndent);
     Indent(indent) << kToolsetTargetEnd;
   }
 }
 
 void GypBinaryTargetWriter::WriteSources(const Target* target, int indent) {
   Indent(indent) << "'sources': [\n";
 
   const Target::FileList& sources = target->sources();
   for (size_t i = 0; i < sources.size(); i++) {
     const SourceFile& input_file = sources[i];
@@ skipping 44 matching lines @@
   if (target_->direct_dependent_configs().empty())
     return;
   Indent(indent) << "'direct_dependent_settings': {\n";
 
   Flags flags(FlagsFromConfigList(target_->direct_dependent_configs()));
   if (target_->settings()->IsLinux())
     WriteLinuxFlags(flags, indent + kExtraIndent);
   else if (target_->settings()->IsWin())
     WriteVCFlags(flags, indent + kExtraIndent);
   else if (target_->settings()->IsMac())
-    WriteMacFlags(flags, indent + kExtraIndent);
+    WriteMacFlags(target_, flags, indent + kExtraIndent);
   Indent(indent) << "},\n";
 }
 
 void GypBinaryTargetWriter::WriteAllDependentSettings(int indent) {
   if (target_->all_dependent_configs().empty())
     return;
   Indent(indent) << "'all_dependent_settings': {\n";
 
   Flags flags(FlagsFromConfigList(target_->all_dependent_configs()));
   if (target_->settings()->IsLinux())
     WriteLinuxFlags(flags, indent + kExtraIndent);
   else if (target_->settings()->IsWin())
     WriteVCFlags(flags, indent + kExtraIndent);
   else if (target_->settings()->IsMac())
-    WriteMacFlags(flags, indent + kExtraIndent);
+    WriteMacFlags(target_, flags, indent + kExtraIndent);
   Indent(indent) << "},\n";
 }
 
 GypBinaryTargetWriter::Flags GypBinaryTargetWriter::FlagsFromTarget(
     const Target* target) const {
   Flags ret;
 
   // Extracts a vector of the given type and name from the config values.
   #define EXTRACT(type, name) \
       { \
@@ skipping 55 matching lines @@
     return;
 
   EscapeOptions options;
   options.mode = ESCAPE_JSON;
 
   Indent(indent) << "'" << name << "': [";
   WriteArrayValues(out_, values);
   out_ << " ],\n";
 }