Convert ios_web_shell_test to GN.

build/config/mac/base_rules.gni

 # 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.
 
 # This file contains rules that are shared between Mac and iOS.
 
 import("//build/toolchain/toolchain.gni")
 import("//build/config/mac/symbols.gni")
 
 if (is_mac) {
@@ skipping 227 matching lines @@
   # that defines the real framework bundle (it will support the current cpu
   # as it is a fat framework).
 
   if (_is_fat_build && !_is_fat_build_main_target) {
     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"
     }
 
     group(_target_name + "+link") {
       forward_variables_from(invoker,
                              [
                                "visibility",
                                "testonly",
                              ])
       public_deps = [
         ":$_target_name($default_toolchain)",
       ]
     }
 
     if (defined(invoker.bundle_deps)) {
       assert(invoker.bundle_deps != [], "mark bundle_deps as used")
     }
   } else {
+    _code_signing_enabled = is_ios && 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_bundle_data = target_name + "_shared_library_bundle_data"
-    _link_shared_library_visibility = [ ":$_shared_library_bundle_data" ]
+    _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",
                                "output_name",
                                "visibility",
                              ])
       visibility = _link_shared_library_visibility
       output_name = _output_name
       output_prefix_override = true
       output_extension = ""
-      output_dir = "$target_out_dir/$_link_shared_library_target"
+
+      if (!_is_fat_build) {
+        output_dir = _shared_library_dir
+      } else {
+        output_dir = _arch_shared_library_dir
+      }
     }
 
     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 = [
-          "$target_out_dir/$_lipo_shared_library_target/$_output_name",
+          "$_shared_library_dir/$_output_name",
         ]
         inputs = [
-          "$target_out_dir/$_link_shared_library_target/$_output_name",
+          "$_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" ]
         }
@@ skipping 31 matching lines @@
               outputs += [ outputs[0] + ".unstripped" ]
               args += [ "-Wcrl,unstripped," +
                         rebase_path(get_path_info(outputs[0], "dir"),
                                     root_build_dir) ]
             }
           }
         }
       }
     }
 
-    bundle_data(_shared_library_bundle_data) {
-      visibility = [ ":$_framework_target" ]
-      forward_variables_from(invoker, [ "testonly" ])
-      outputs = [
-        "{{bundle_executable_dir}}/$_output_name",
-      ]
-      if (_is_fat_build) {
+    if (!_code_signing_enabled) {
+      bundle_data(_shared_library_bundle_data) {
+        visibility = [ ":$_framework_target" ]
+        forward_variables_from(invoker, [ "testonly" ])
         sources = [
-          "$target_out_dir/$_lipo_shared_library_target/$_output_name",
+          "$_shared_library_dir/$_output_name",
         ]
-        public_deps = [
-          ":$_lipo_shared_library_target",
+        outputs = [
+          "{{bundle_executable_dir}}/$_output_name",
         ]
-      } else {
-        sources = [
-          "$target_out_dir/$_link_shared_library_target/$_output_name",
-        ]
-        public_deps = [
-          ":$_link_shared_library_target",
-        ]
+        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) ]
+      ldflags = [
+        "-F",
+        rebase_path("$root_out_dir/.", root_build_dir),
+      ]
       lib_dirs = [ root_out_dir ]
       libs = [ _framework_name ]
     }
 
     create_bundle(_framework_target) {
       forward_variables_from(invoker,
                              [
                                "data_deps",
                                "deps",
                                "public_deps",
                                "testonly",
                              ])
 
       if (defined(_framework_version)) {
         visibility = [ ":$_target_name" ]
       } else {
         if (defined(invoker.visibility)) {
           visibility = invoker.visibility
           visibility += [ ":$_target_name+link" ]
         }
       }
 
-      if (!defined(public_deps)) {
-        public_deps = []
-      }
-      public_deps += [ ":$_shared_library_bundle_data" ]
+      if (!_code_signing_enabled) {
+        if (!defined(public_deps)) {
+          public_deps = []
+        }
+        public_deps += [ ":$_shared_library_bundle_data" ]
 
-      if (defined(invoker.bundle_deps)) {
-        public_deps += invoker.bundle_deps
+        if (defined(invoker.bundle_deps)) {
+          if (!defined(deps)) {
+            deps = []
+          }
+          deps += invoker.bundle_deps
+        }
       }
 
       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 = "$ios_sdk_path/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 = [
+          "-i=" + ios_code_signing_identity,
+          "-b=" +
+              rebase_path("$_shared_library_dir/$_output_name", root_build_dir),
+          "-e=" + rebase_path(_entitlements_path, root_build_dir),
+          rebase_path(bundle_root_dir, root_build_dir),
+        ]
+      }
     }
 
     if (defined(_framework_version)) {
       action(_target_name) {
         forward_variables_from(invoker, [ "testonly" ])
 
         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",
         ]
       }
     }
 
     group(_target_name + "+link") {
       forward_variables_from(invoker,
                              [
+                               "public_configs",
+                               "testonly",
                                "visibility",
-                               "testonly",
                              ])
       public_deps = [
         ":$_target_name",
       ]
-      public_configs = [ ":$_framework_public_config" ]
+      if (!defined(public_configs)) {
+        public_configs = []
+      }
+      public_configs += [ ":$_framework_public_config" ]
     }
   }
 }
 
 # Template to combile .xib or .storyboard files.
 #
 # Arguments
 #
 #     sources:
 #         list of string, sources to compile
@@ skipping 22 matching lines @@
     ]
     args =
         [
           "--input",
           "{{source}}",
           "--output",
           rebase_path("$target_gen_dir/$target_name/{{source_name_part}}.nib"),
         ] + ibtool_flags
   }
 }