Stop sharing code between ios_framework_bundle & mac_framework_bundle.

build/config/ios/rules.gni

 # Copyright 2015 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.
 
 import("//build/config/ios/ios_sdk.gni")
 import("//build/config/mac/base_rules.gni")
 import("//build/config/mac/symbols.gni")
 
+_toolchain_suffix = ""
+_is_fat_build = additional_toolchains != []
+if (_is_fat_build) {
+  _toolchain_suffix = "($default_toolchain)"
+  _is_fat_build_main_target = current_toolchain == default_toolchain
+}
+
 # Generates Info.plist files for Mac apps and frameworks.
 #
 # Arguments
 #
 #     info_plist:
 #         (optional) string, path to the Info.plist file that will be used for
 #         the bundle.
 #
 #     info_plist_target:
 #         (optional) string, if the info_plist is generated from an action,
@@ skipping 120 matching lines @@
   #
   # The target for the default toolchain of a multi-architecture build will
   # build the executable for current_cpu in a temporary location. The real
   # fat binary will be created by "lipo" command from all those "executable"
   # target (including those of the non-default toolchains). This additional
   # target has the same role as the "executable" target of a thin build.
   #
   # The rest of the build, including the codesigning step, are the same for
   # thin and fat builds.
 
-  _is_fat_build = additional_toolchains != []
-  if (_is_fat_build) {
-    _is_fat_build_main_target = current_toolchain == default_toolchain
-  }
-
   _executable_extra_deps = []
   _executable_extra_inputs = []
   _executable_extra_ldflags = []
 
   # Embeds the entitlements file if building for simulator. This is optional
   # with Xcode 7 or older but required with Xcode 8. This is not necessary for
   # device build as the entitlement is embedded via the codesigning step.
   #
   # As the generation of the entitlement depends on the
   if (use_ios_simulator) {
-    _toolchain_suffix = ""
-    if (_is_fat_build && !_is_fat_build_main_target) {
-      _toolchain_suffix = "($default_toolchain)"
-    }
-
     _generate_entitlements_target = _target_name + "_gen_entitlements"
     _generate_entitlements_target_with_toolchain_suffix =
         "$_generate_entitlements_target$_toolchain_suffix"
 
     _generate_entitlements_output =
         get_label_info(_generate_entitlements_target_with_toolchain_suffix,
                        "target_gen_dir") + "/$_output_name.xcent"
 
     _executable_extra_inputs += [ _generate_entitlements_output ]
     _executable_extra_deps +=
@@ skipping 577 matching lines @@
     sources = get_target_outputs(":$_convert_target")
 
     outputs = [
       invoker.output,
     ]
   }
 }
 
 # Template to package a shared library into an iOS framework bundle.
 #
-# This template provides two targets to control whether the framework is
-# merely built when targets depend on it, or whether it is linked as well:
-# "$target_name" and "$target_name+link".
-#
-# See the //build/config/mac/base_rules.gni:framework_bundle for a discussion
-# and examples.
+# By default, the bundle target this template generates does not link the
+# resulting framework into anything that depends on it. If a dependency wants
+# a link-time (as well as build-time) dependency on the framework bundle,
+# depend against "$target_name+link". If only the build-time dependency is
+# required (e.g., for copying into another bundle), then use "$target_name".
 #
 # Arguments
 #
 #     output_name:
 #         (optional) string, name of the generated framework without the
 #         .framework suffix. If omitted, defaults to target_name.
 #
 #     framework_version:
 #         (optional) string, version of the framework. Typically this is a
 #         single letter, like "A". If omitted, the Versions/ subdirectory
 #         structure will not be created, and build output will go directly
 #         into the framework subdirectory.
 #
 #     public_headers:
 #         (optional) list of paths to header file that needs to be copied
 #         into the framework bundle Headers subdirectory. If omitted or
 #         empty then the Headers subdirectory is not created.
 #
 #     sources
 #         (optional) list of files. Needs to be defined and non-empty if
 #         public_headers is defined and non-empty.
 #
+# This template provides two targets for the resulting framework bundle. The
+# link-time behavior varies depending on which of the two targets below is
+# added as a dependency:
+#   - $target_name only adds a build-time dependency. Targets that depend on
+#     it will not link against the framework.
+#   - $target_name+link adds a build-time and link-time dependency. Targets
+#     that depend on it will link against the framework.
+#
+# The build-time-only dependency is used for when a target needs to use the
+# framework either only for resources, or because the target loads it at run-
+# time, via dlopen() or NSBundle. The link-time dependency will cause the
+# dependee to have the framework loaded by dyld at launch.
+#
+# Example of build-time only dependency:
+#
+#     framework_bundle("CoreTeleportation") {
+#       sources = [ ... ]
+#     }
+#
+#     bundle_data("core_teleportation_bundle_data") {
+#       deps = [ ":CoreTeleportation" ]
+#       sources = [ "$root_out_dir/CoreTeleportation.framework" ]
+#       outputs = [ "{{bundle_root_dir}}/Frameworks/{{source_file_part}}" ]
+#     }
+#
+#     app_bundle("GoatTeleporter") {
+#       sources = [ ... ]
+#       deps = [
+#         ":core_teleportation_bundle_data",
+#       ]
+#     }
+#
+# The GoatTeleporter.app will not directly link against
+# CoreTeleportation.framework, but it will be included in the bundle's
+# Frameworks directory.
+#
+# Example of link-time dependency:
+#
+#     framework_bundle("CoreTeleportation") {
+#       sources = [ ... ]
+#       ldflags = [
+#         "-install_name",
+#         "@executable_path/../Frameworks/$target_name.framework"
+#       ]
+#     }
+#
+#     bundle_data("core_teleportation_bundle_data") {
+#       deps = [ ":CoreTeleportation+link" ]
+#       sources = [ "$root_out_dir/CoreTeleportation.framework" ]
+#       outputs = [ "{{bundle_root_dir}}/Frameworks/{{source_file_part}}" ]
+#     }
+#
+#     app_bundle("GoatTeleporter") {
+#       sources = [ ... ]
+#       deps = [
+#         ":core_teleportation_bundle_data",
+#       ]
+#     }
+#
+# Note that the framework is still copied to the app's bundle, but dyld will
+# load this library when the app is launched because it uses the "+link"
+# target as a dependency. This also requires that the framework set its
+# install_name so that dyld can locate it.
+#
 # See "gn help shared_library" for more information on arguments supported
 # by shared library target.
 template("ios_framework_bundle") {
   _target_name = target_name
   _output_name = target_name
   if (defined(invoker.output_name)) {
     _output_name = invoker.output_name
   }
-  _framework_target = _target_name
 
   _has_public_headers =
       defined(invoker.public_headers) && invoker.public_headers != []
 
-  _is_fat_build = additional_toolchains != []
-  if (_is_fat_build) {
-    _is_fat_build_main_target = current_toolchain == default_toolchain
+  if (_has_public_headers) {
+    _framework_headers_target = _target_name + "_framework_headers"
+    _framework_headers_config = _target_name + "_framework_headers_config"
+    _headers_map_config = _target_name + "_headers_map"
   }
 
-  # This template has a different expansion depending on whether public headers
-  # are defined or not. If no public headers are speficied, then is forwards to
-  # the generic "framework_bundle" target, otherwise if expands to targets that
-  # create header map mapping and corresponding config and configure them as
-  # dependencies of the generic "framework_bundle" target.
+  # The expansion of the template is different for fat and thin builds. For
+  # thin build (and default toolchain of a fat build), the template expands
+  # to a "shared_library" target to create the bundle shared library and a
+  # "create_bundle" target (the main target) to create the bundle structure.
   #
-  # The expansion is a bit different for multi-architecture builds (aka fat
-  # binary builds). Then the targets build for the non-default toolchain uses
-  # the same header map (if available) as the one used by the default toolchain.
+  # For a fat build, the template just expands to the "shared_library" target
+  # for the non-default toolchain, while the final library is created using
+  # "lipo" in the expansion of the template for the default toolchain.
+  #
+  # The "$target_name+link" group for the non-default toolchain depends on the
+  # target of the same name from the default toolchain as this is the target
+  # that defines the real framework bundle (it will support the current cpu
+  # as it is a fat framework).
 
-  _toolchain_suffix = ""
   if (_is_fat_build && !_is_fat_build_main_target) {
-    _toolchain_suffix = "($default_toolchain)"
-  }
+    shared_library(_target_name) {
+      forward_variables_from(invoker,
+                             "*",
+                             [
+                               "assert_no_deps",
+                               "bundle_deps",
+                               "code_signing_enabled",
+                               "data_deps",
+                               "info_plist",
+                               "info_plist_target",
+                               "output_name",
+                             ])
+      if (defined(visibility)) {
+        visibility += [ ":${_target_name}_shared_library($default_toolchain)" ]
+      }
+      output_name = _output_name
+      output_prefix_override = true
+      output_extension = ""
+      output_dir = "$target_out_dir/$_target_name"
 
-  if (_has_public_headers) {
-    _framework_headers_target = _target_name + "_framework_headers"
-    _framework_public_config = _target_name + "_ios_public_config"
-    _framework_target = target_name + "_internal"
-    _headers_map_config = _target_name + "_headers_map"
+      if (_has_public_headers) {
+        configs += [
+          ":$_framework_headers_config$_toolchain_suffix",
+          ":$_headers_map_config$_toolchain_suffix",
+        ]
 
-    if (!_is_fat_build || _is_fat_build_main_target) {
+        if (!defined(deps)) {
+          deps = []
+        }
+        deps += [ ":$_framework_headers_target$_toolchain_suffix" ]
+      }
+    }
+
+    group(_target_name + "+link") {
+      forward_variables_from(invoker,
+                             [
+                               "visibility",
+                               "testonly",
+                             ])
+      public_deps = [
+        ":$_target_name+link($default_toolchain)",
+      ]
+    }
+
+    if (defined(invoker.bundle_deps)) {
+      assert(invoker.bundle_deps != [], "mark bundle_deps as used")
+    }
+  } else {
+    if (_has_public_headers) {
       _public_headers = invoker.public_headers
       _framework_name = _output_name + ".framework"
       _framework_root = "$root_out_dir/$_framework_name"
 
       _header_map_filename = "$target_gen_dir/$_output_name.headers.hmap"
 
       _compile_headers_map_target = _target_name + "_compile_headers_map"
       action(_compile_headers_map_target) {
         visibility = [ ":$_framework_headers_target" ]
         script = "//build/config/ios/write_framework_hmap.py"
@@ skipping 50 matching lines @@
       }
 
       group(_framework_headers_target) {
         deps = [
           ":$_compile_headers_map_target",
           ":$_copy_public_headers_target",
           ":$_create_module_map_target",
         ]
       }
 
-      config(_framework_public_config) {
+      config(_framework_headers_config) {
         # The link settings are inherited from the framework_bundle config.
         cflags = [
           "-F",
           rebase_path("$root_out_dir/.", root_build_dir),
         ]
       }
     }
-  }
 
-  if (!_is_fat_build || _is_fat_build_main_target) {
+    _code_signing_enabled = ios_enable_code_signing
+    if (defined(invoker.code_signing_enabled)) {
+      _code_signing_enabled =
+          invoker.code_signing_enabled && _code_signing_enabled
+    }
+
+    # If the framework is unversioned, the final _target_name will be the
+    # create_bundle(_framework_target), otherwise an action with the name
+    # _target_name will depends on the the create_bundle() in order to prepare
+    # the versioned directory structure.
+    _framework_target = _target_name
+    _framework_name = _output_name + ".framework"
+    _framework_root_dir = "$root_out_dir/$_framework_name"
+    if (defined(invoker.framework_version) && invoker.framework_version != "") {
+      _framework_version = invoker.framework_version
+      _framework_root_dir += "/Versions/$_framework_version"
+      _framework_target = _target_name + "_create_bundle"
+    }
+
+    _link_shared_library_target = target_name + "_shared_library"
+    _shared_library_dir = "$target_out_dir/$_link_shared_library_target"
+
+    if (_code_signing_enabled) {
+      _link_shared_library_visibility = [ ":$_framework_target" ]
+    } else {
+      _shared_library_bundle_data = target_name + "_shared_library_bundle_data"
+      _link_shared_library_visibility = [ ":$_shared_library_bundle_data" ]
+    }
+
+    if (_is_fat_build) {
+      _lipo_shared_library_target = _link_shared_library_target
+      _lipo_shared_library_visibility = _link_shared_library_visibility
+
+      _link_shared_library_visibility = []
+      _link_shared_library_visibility = [ ":$_lipo_shared_library_target" ]
+      _link_shared_library_target = target_name + "_arch_shared_library"
+
+      _arch_shared_library_dir = "$target_out_dir/$_link_shared_library_target"
+      _shared_library_dir = "$target_out_dir/$_lipo_shared_library_target"
+    }
+
+    shared_library(_link_shared_library_target) {
+      forward_variables_from(invoker,
+                             "*",
+                             [
+                               "assert_no_deps",
+                               "bundle_deps",
+                               "code_signing_enabled",
+                               "data_deps",
+                               "info_plist",
+                               "info_plist_target",
+                               "output_name",
+                               "visibility",
+                             ])
+      visibility = _link_shared_library_visibility
+      output_name = _output_name
+      output_prefix_override = true
+      output_extension = ""
+
+      if (!_is_fat_build) {
+        output_dir = _shared_library_dir
+      } else {
+        output_dir = _arch_shared_library_dir
+      }
+
+      if (_has_public_headers) {
+        configs += [ ":$_headers_map_config$_toolchain_suffix" ]
+
+        if (!defined(deps)) {
+          deps = []
+        }
+        deps += [ ":$_framework_headers_target$_toolchain_suffix" ]
+      }
+    }
+
+    if (_is_fat_build) {
+      action(_lipo_shared_library_target) {
+        forward_variables_from(invoker, [ "testonly" ])
+        visibility = _lipo_shared_library_visibility
+        script = "//build/toolchain/mac/linker_driver.py"
+        outputs = [
+          "$_shared_library_dir/$_output_name",
+        ]
+        inputs = [
+          "$_arch_shared_library_dir/$_output_name",
+        ]
+        deps = [
+          ":$_link_shared_library_target",
+        ]
+        foreach(_additional_toolchain, additional_toolchains) {
+          _additional_toolchain_target = "$_target_name($_additional_toolchain)"
+          deps += [ ":$_additional_toolchain_target" ]
+          inputs += [ get_label_info(_additional_toolchain_target,
+                                     "target_out_dir") + "/$_output_name" ]
+        }
+        args = [
+                 "xcrun",
+                 "lipo",
+                 "-create",
+                 "-output",
+                 rebase_path(outputs[0], root_build_dir),
+               ] + rebase_path(inputs, root_build_dir)
+
+        if (enable_dsyms) {
+          outputs += [ "$root_out_dir/$_output_name.dSYM/" ]
+          args +=
+              [ "-Wcrl,dsym," + rebase_path("$root_out_dir/.", root_build_dir) ]
+        }
+
+        if (enable_stripping) {
+          # Check whether //build/config/mac:strip_all has been removed from
+          # the configs variable (as this is how stripping is disabled for a
+          # single target).
+          _strip_all_in_config = false
+          if (defined(invoker.configs)) {
+            foreach(_config, invoker.configs) {
+              if (_config == "//build/config/mac:strip_all") {
+                _strip_all_in_config = true
+              }
+            }
+          }
+
+          if (_strip_all_in_config) {
+            args += [ "-Wcrl,strip,-x,-S" ]
+
+            if (save_unstripped_output) {
+              outputs += [ outputs[0] + ".unstripped" ]
+              args += [ "-Wcrl,unstripped," +
+                        rebase_path(get_path_info(outputs[0], "dir"),
+                                    root_build_dir) ]
+            }
+          }
+        }
+      }
+    }
+
+    if (!_code_signing_enabled) {
+      bundle_data(_shared_library_bundle_data) {
+        visibility = [ ":$_framework_target" ]
+        forward_variables_from(invoker, [ "testonly" ])
+        sources = [
+          "$_shared_library_dir/$_output_name",
+        ]
+        outputs = [
+          "{{bundle_executable_dir}}/$_output_name",
+        ]
+        if (_is_fat_build) {
+          public_deps = [
+            ":$_lipo_shared_library_target",
+          ]
+        } else {
+          public_deps = [
+            ":$_link_shared_library_target",
+          ]
+        }
+      }
+    }
+
+    _framework_public_config = _target_name + "_public_config"
+    config(_framework_public_config) {
+      # TODO(sdefresne): should we have a framework_dirs similar to lib_dirs
+      # and include_dirs to avoid duplicate values on the command-line.
+      visibility = [ ":$_framework_target" ]
+      ldflags = [
+        "-F",
+        rebase_path("$root_out_dir/.", root_build_dir),
+      ]
+      lib_dirs = [ root_out_dir ]
+      libs = [ _framework_name ]
+    }
+
     _info_plist_target = _target_name + "_info_plist"
     _info_plist_bundle = _target_name + "_info_plist_bundle"
     ios_info_plist(_info_plist_target) {
       visibility = [ ":$_info_plist_bundle" ]
       executable_name = _output_name
       forward_variables_from(invoker,
                              [
                                "extra_substitutions",
                                "info_plist",
                                "info_plist_target",
                              ])
     }
 
     bundle_data(_info_plist_bundle) {
-      visibility = [ ":$_framework_target" ]
+      visibility = [ ":$_target_name" ]
       forward_variables_from(invoker, [ "testonly" ])
       sources = get_target_outputs(":$_info_plist_target")
       outputs = [
         "{{bundle_root_dir}}/Info.plist",
       ]
       public_deps = [
         ":$_info_plist_target",
       ]
     }
-  }
 
-  framework_bundle(_framework_target) {
-    forward_variables_from(invoker,
-                           "*",
-                           [
-                             "output_name",
-                             "public_headers",
-                             "visibility",
-                           ])
-    output_name = _output_name
+    create_bundle(_framework_target) {
+      forward_variables_from(invoker,
+                             [
+                               "data_deps",
+                               "deps",
+                               "public_configs",
+                               "public_deps",
+                               "testonly",
+                             ])
 
-    if (!_is_fat_build || _is_fat_build_main_target) {
-      if (!defined(bundle_deps)) {
-        bundle_deps = []
+      if (defined(_framework_version)) {
+        visibility = [ ":$_target_name" ]
+      } else {
+        if (defined(invoker.visibility)) {
+          visibility = invoker.visibility
+          visibility += [ ":$_target_name+link" ]
+        }
       }
-      bundle_deps += [ ":$_info_plist_bundle" ]
-    }
-
-    if (_has_public_headers) {
-      if (!defined(public_configs)) {
-        public_configs = []
-      }
-      public_configs += [ ":$_framework_public_config$_toolchain_suffix" ]
-    }
-
-    if (_has_public_headers) {
-      visibility = [
-        ":$_target_name$_toolchain_suffix",
-        ":$_target_name+link$_toolchain_suffix",
-        ":$_target_name+bundle$_toolchain_suffix",
-      ]
-      configs += [ ":$_headers_map_config$_toolchain_suffix" ]
 
       if (!defined(deps)) {
         deps = []
       }
-      deps += [ ":$_framework_headers_target$_toolchain_suffix" ]
-    } else {
-      if (defined(invoker.visibility)) {
-        visibility = invoker.visibility
-        visibility += [ ":$_target_name+link$_toolchain_suffix" ]
+      deps += [ ":$_info_plist_bundle" ]
+
+      if (defined(invoker.bundle_deps)) {
+        if (!defined(deps)) {
+          deps = []
+        }
+        deps += invoker.bundle_deps
+      }
+
+      if (!_code_signing_enabled) {
+        if (!defined(public_deps)) {
+          public_deps = []
+        }
+        public_deps += [ ":$_shared_library_bundle_data" ]
+      }
+
+      bundle_root_dir = _framework_root_dir
+      bundle_resources_dir = "$bundle_root_dir/Resources"
+      bundle_executable_dir = "$bundle_root_dir"
+
+      if (_code_signing_enabled) {
+        if (!defined(deps)) {
+          deps = []
+        }
+
+        if (_is_fat_build) {
+          deps += [ ":$_lipo_shared_library_target" ]
+        } else {
+          deps += [ ":$_link_shared_library_target" ]
+        }
+
+        _entitlements_path = "//build/config/ios/entitlements.plist"
+        if (defined(invoker.entitlements_path)) {
+          _entitlements_path = invoker.entitlements_path
+        }
+
+        code_signing_script = "//build/config/ios/codesign.py"
+        code_signing_sources = [
+          _entitlements_path,
+          "$_shared_library_dir/$_output_name",
+        ]
+        code_signing_outputs = [
+          "$bundle_root_dir/$_output_name",
+          "$bundle_root_dir/_CodeSignature/CodeResources",
+          "$bundle_root_dir/embedded.mobileprovision",
+        ]
+        code_signing_args = [
+          "-e=" + rebase_path(_entitlements_path, root_build_dir),
+          "code-sign-bundle",
+          "-i=" + ios_code_signing_identity,
+          "-b=" +
+              rebase_path("$_shared_library_dir/$_output_name", root_build_dir),
+          rebase_path(bundle_root_dir, root_build_dir),
+        ]
       }
     }
-  }
 
-  if (_has_public_headers) {
-    group(_target_name) {
-      forward_variables_from(invoker,
-                             [
-                               "testonly",
-                               "public_configs",
-                             ])
+    if (defined(_framework_version)) {
+      action(_target_name) {
+        forward_variables_from(invoker, [ "testonly" ])
 
-      if (defined(invoker.visibility)) {
-        visibility = invoker.visibility
-        visibility += [ ":$_target_name+link" ]
+        if (defined(invoker.visibility)) {
+          visibility = invoker.visibility
+          visibility += [ ":$_target_name+link" ]
+        }
+
+        script = "//build/config/mac/package_framework.py"
+        outputs = [
+          "$root_out_dir/$_framework_name/Versions/Current",
+        ]
+        args = [
+          "$_framework_name",
+          "$_framework_version",
+        ]
+        public_deps = [
+          ":$_framework_target",
+        ]
       }
-
-      public_deps = [
-        ":$_framework_target$_toolchain_suffix",
-      ]
     }
 
     group(_target_name + "+link") {
       forward_variables_from(invoker,
                              [
+                               "public_deps",
+                               "public_configs",
                                "testonly",
                                "visibility",
                              ])
-      public_deps = [
-        ":$_framework_target+link$_toolchain_suffix",
-      ]
+      if (!defined(public_deps)) {
+        public_deps = []
+      }
+      public_deps += [ ":$_target_name" ]
+      if (!defined(public_configs)) {
+        public_configs = []
+      }
+      public_configs += [ ":$_framework_public_config" ]
+
+      if (_has_public_headers) {
+        public_configs += [ ":$_framework_headers_config" ]
+      }
     }
-  }
 
-  if (!_is_fat_build || _is_fat_build_main_target) {
     bundle_data(_target_name + "+bundle") {
       forward_variables_from(invoker,
                              [
                                "testonly",
                                "visibility",
                              ])
       public_deps = [
-        ":$_framework_target",
+        ":$_target_name",
       ]
       sources = [
         "$root_out_dir/$_output_name.framework",
       ]
       outputs = [
         "{{bundle_resources_dir}}/Frameworks/$_output_name.framework",
       ]
     }
   }
 }
 
 set_defaults("ios_framework_bundle") {
   configs = default_shared_library_configs
 }
 
 # For Chrome on iOS we want to run XCTests for all our build configurations
 # (Debug, Release, ...). In addition, the symbols visibility is configured to
 # private by default. To simplify testing with those constraints, our tests are
 # compiled in the TEST_HOST target instead of the .xctest bundle.
 template("ios_xctest_test") {
   _target_name = target_name
   _output_name = target_name
   if (defined(invoker.output_name)) {
     _output_name = invoker.output_name
   }
 
-  _is_fat_build = additional_toolchains != []
-  if (_is_fat_build) {
-    _is_fat_build_main_target = current_toolchain == default_toolchain
-  }
-
   _xctest_target = _target_name
   _xctest_output = _output_name
 
   _host_target = _target_name + "_host"
   _host_output = _output_name + "_host"
 
   if (_is_fat_build && !_is_fat_build_main_target) {
     loadable_module(_xctest_target) {
       visibility = [ ":${_xctest_target}_loadable_module($default_toolchain)" ]
       sources = [
@@ skipping 242 matching lines @@
       "-rpath",
       "-Xlinker",
       "@loader_path/Frameworks",
     ]
   }
 }
 
 set_defaults("ios_xctest_test") {
   configs = default_executable_configs
 }