xref: /aosp_15_r20/external/cronet/build/config/BUILDCONFIG.gn (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b)

# Copyright 2013 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# =============================================================================
# WHAT IS THIS FILE?
# =============================================================================
#
# This is the main GN build configuration. This file is loaded after the
# build args (args.gn) for the build directory and after the toplevel ".gn"
# file (which points to this file as the build configuration).
#
# This file will be executed and the resulting context will be used to execute
# every other file in the build. So variables declared here (that don't start
# with an underscore) will be implicitly global.

# =============================================================================
# PLATFORM SELECTION
# =============================================================================
#
# There are two main things to set: "os" and "cpu". The "toolchain" is the name
# of the GN thing that encodes combinations of these things.
#
# Users typically only set the variables "target_os" and "target_cpu" in "gn
# args", the rest are set up by our build and internal to GN.
#
# There are three different types of each of these things: The "host"
# represents the computer doing the compile and never changes. The "target"
# represents the main thing we're trying to build. The "current" represents
# which configuration is currently being defined, which can be either the
# host, the target, or something completely different (like nacl). GN will
# run the same build file multiple times for the different required
# configuration in the same build.
#
# This gives the following variables:
#  - host_os, host_cpu, host_toolchain
#  - target_os, target_cpu, default_toolchain
#  - current_os, current_cpu, current_toolchain.
#
# Note the default_toolchain isn't symmetrical (you would expect
# target_toolchain). This is because the "default" toolchain is a GN built-in
# concept, and "target" is something our build sets up that's symmetrical with
# its GYP counterpart. Potentially the built-in default_toolchain variable
# could be renamed in the future.
#
# When writing build files, to do something only for the host:
#   if (current_toolchain == host_toolchain) { ...

if (target_os == "") {
  target_os = host_os
}

if (target_cpu == "") {
  if (target_os == "android") {
    # If we're building for Android, we should assume that we want to
    # build for ARM by default, not the host_cpu (which is likely x64).
    # This allows us to not have to specify both target_os and target_cpu
    # on the command line.
    target_cpu = "arm"
  } else {
    target_cpu = host_cpu
  }
}

if (current_cpu == "") {
  current_cpu = target_cpu
}
if (current_os == "") {
  current_os = target_os
}

# =============================================================================
# BUILD FLAGS
# =============================================================================
#
# This block lists input arguments to the build, along with their default
# values.
#
# If a value is specified on the command line, it will overwrite the defaults
# given in a declare_args block, otherwise the default will be used.
#
# YOU SHOULD ALMOST NEVER NEED TO ADD FLAGS TO THIS FILE. GN allows any file in
# the build to declare build flags. If you need a flag for a single component,
# you can just declare it in the corresponding BUILD.gn file.
#
# - If your feature is a single target, say //components/foo, you can put
#   a declare_args() block in //components/foo/BUILD.gn and use it there.
#   Nobody else in the build needs to see the flag.
#
# - Defines based on build variables should be implemented via the generated
#   build flag header system. See //build/buildflag_header.gni. You can put
#   the buildflag_header target in the same file as the build flag itself. You
#   should almost never set "defines" directly.
#
# - If your flag toggles a target on and off or toggles between different
#   versions of similar things, write a "group" target that forwards to the
#   right target (or no target) depending on the value of the build flag. This
#   group can be in the same BUILD.gn file as the build flag, and targets can
#   depend unconditionally on the group rather than duplicating flag checks
#   across many targets.
#
# - If a semi-random set of build files REALLY needs to know about a define and
#   the above pattern for isolating the build logic in a forwarding group
#   doesn't work, you can put the argument in a .gni file. This should be put
#   in the lowest level of the build that knows about this feature (which should
#   almost always be outside of the //build directory!).
#
# Other flag advice:
#
# - Use boolean values when possible. If you need a default value that expands
#   to some complex thing in the default case (like the location of the
#   compiler which would be computed by a script), use a default value of -1 or
#   the empty string. Outside of the declare_args block, conditionally expand
#   the default value as necessary.
#
# - Use a name like "use_foo" or "is_foo" (whatever is more appropriate for
#   your feature) rather than just "foo".
#
# - Write good comments directly above the declaration with no blank line.
#   These comments will appear as documentation in "gn args --list".
#
# - Don't call exec_script inside declare_args. This will execute the script
#   even if the value is overridden, which is wasteful. See first bullet.

declare_args() {
  # Set to enable the official build level of optimization. This has nothing
  # to do with branding, but enables an additional level of optimization above
  # release (!is_debug). This might be better expressed as a tri-state
  # (debug, release, official) but for historical reasons there are two
  # separate flags.
  #
  # IMPORTANT NOTE: (!is_debug) is *not* sufficient to get satisfying
  # performance. In particular, DCHECK()s are still enabled for release builds,
  # which can halve overall performance, and do increase memory usage. Always
  # set "is_official_build" to true for any build intended to ship to end-users.
  is_official_build = false

  # Set to true when compiling with the Clang compiler.
  is_clang = current_os != "linux" ||
             (current_cpu != "s390x" && current_cpu != "s390" &&
              current_cpu != "ppc64" && current_cpu != "ppc" &&
              current_cpu != "mips" && current_cpu != "mips64" &&
              current_cpu != "riscv64")

  # Allows the path to a custom target toolchain to be injected as a single
  # argument, and set as the default toolchain.
  custom_toolchain = ""

  # This should not normally be set as a build argument.  It's here so that
  # every toolchain can pass through the "global" value via toolchain_args().
  host_toolchain = ""

  # Do not set this directly.
  # It should be set only by //build/toolchains/android:robolectric_x64.
  # True when compiling native code for use with robolectric_binary().
  is_robolectric = false

  # DON'T ADD MORE FLAGS HERE. Read the comment above.
}

declare_args() {
  # Debug build. Enabling official builds automatically sets is_debug to false.
  is_debug = !is_official_build
}

declare_args() {
  # Component build. Setting to true compiles targets declared as "components"
  # as shared libraries loaded dynamically. This speeds up development time.
  # When false, components will be linked statically.
  #
  # For more information see
  # https://chromium.googlesource.com/chromium/src/+/main/docs/component_build.md
  is_component_build = is_debug && current_os != "ios"
}

assert(!(is_debug && is_official_build), "Can't do official debug builds")
assert(!(current_os == "ios" && is_component_build),
       "Can't use component build on iOS")

declare_args() {
  # Unsafe buffers. Location of file used by plugins to track portions of
  # the codebase which have been made manifestly safe.
  clang_unsafe_buffers_paths = ""
}

# ==============================================================================
# TOOLCHAIN SETUP
# ==============================================================================
#
# Here we set the default toolchain, as well as the variable host_toolchain
# which will identify the toolchain corresponding to the local system when
# doing cross-compiles. When not cross-compiling, this will be the same as the
# default toolchain.
#
# We do this before anything else to make sure we complain about any
# unsupported os/cpu combinations as early as possible.

if (host_toolchain == "") {
  # This should only happen in the top-level context.
  # In a specific toolchain context, the toolchain_args()
  # block should have propagated a value down.
  # TODO(dpranke): Add some sort of assert here that verifies that
  # no toolchain omitted host_toolchain from its toolchain_args().

  if (host_os == "linux") {
    if (target_os != "linux") {
      host_toolchain = "//build/toolchain/linux:clang_$host_cpu"
    } else if (is_clang) {
      host_toolchain = "//build/toolchain/linux:clang_$host_cpu"
    } else {
      host_toolchain = "//build/toolchain/linux:$host_cpu"
    }
  } else if (host_os == "mac") {
    host_toolchain = "//build/toolchain/mac:clang_$host_cpu"
  } else if (host_os == "win") {
    # On Windows always use the target CPU for host builds for x86/x64. On the
    # configurations we support this will always work and it saves build steps.
    # Windows ARM64 targets require an x64 host for cross build.
    if (target_cpu == "x86" || target_cpu == "x64") {
      if (is_clang) {
        host_toolchain = "//build/toolchain/win:win_clang_$target_cpu"
      } else {
        host_toolchain = "//build/toolchain/win:$target_cpu"
      }
    } else if (is_clang) {
      host_toolchain = "//build/toolchain/win:win_clang_$host_cpu"
    } else {
      host_toolchain = "//build/toolchain/win:$host_cpu"
    }
  } else if (host_os == "aix") {
    host_toolchain = "//build/toolchain/aix:$host_cpu"
  } else if (host_os == "zos") {
    host_toolchain = "//build/toolchain/zos:$host_cpu"
  } else {
    assert(false, "Unsupported host_os: $host_os")
  }
}

_default_toolchain = ""

if (target_os == "android") {
  assert(host_os == "linux", "Android builds are only supported on Linux.")
  _default_toolchain = "//build/toolchain/android:android_clang_$target_cpu"
} else if (target_os == "chromeos" || target_os == "linux") {
  # See comments in build/toolchain/cros/BUILD.gn about board compiles.
  if (is_clang) {
    _default_toolchain = "//build/toolchain/linux:clang_$target_cpu"
  } else {
    _default_toolchain = "//build/toolchain/linux:$target_cpu"
  }
} else if (target_os == "fuchsia") {
  _default_toolchain = "//build/toolchain/fuchsia:$target_cpu"
} else if (target_os == "ios") {
  _default_toolchain = "//build/toolchain/ios:ios_clang_$target_cpu"
} else if (target_os == "mac") {
  assert(host_os == "mac" || host_os == "linux",
         "Mac cross-compiles are unsupported.")
  _default_toolchain = "//build/toolchain/mac:clang_$target_cpu"
} else if (target_os == "win") {
  # On Windows, we use the same toolchain for host and target by default.
  # Beware, win cross builds have some caveats, see docs/win_cross.md
  if (is_clang) {
    _default_toolchain = "//build/toolchain/win:win_clang_$target_cpu"
  } else {
    _default_toolchain = "//build/toolchain/win:$target_cpu"
  }
} else if (target_os == "winuwp") {
  # Only target WinUWP on for a Windows store application and only
  # x86, x64 and arm are supported target CPUs.
  assert(target_cpu == "x86" || target_cpu == "x64" || target_cpu == "arm" ||
         target_cpu == "arm64")
  _default_toolchain = "//build/toolchain/win:uwp_$target_cpu"
} else if (target_os == "aix") {
  _default_toolchain = "//build/toolchain/aix:$target_cpu"
} else if (target_os == "zos") {
  _default_toolchain = "//build/toolchain/zos:$target_cpu"
} else {
  assert(false, "Unsupported target_os: $target_os")
}

# If a custom toolchain has been set in the args, set it as default. Otherwise,
# set the default toolchain for the platform (if any).
if (custom_toolchain != "") {
  set_default_toolchain(custom_toolchain)
} else if (_default_toolchain != "") {
  set_default_toolchain(_default_toolchain)
}

# =============================================================================
# OS DEFINITIONS
# =============================================================================
#
# We set these various is_FOO booleans for convenience in writing OS-based
# conditions.
#
# - is_android, is_chromeos, is_ios, and is_win should be obvious.
# - is_mac is set only for desktop Mac. It is not set on iOS.
# - is_posix is true for mac and any Unix-like system (basically everything
#   except Fuchsia and Windows).
# - is_linux is true for desktop Linux, but not for ChromeOS nor Android (which
#   is generally too different despite being based on the Linux kernel).
#
# Do not add more is_* variants here for random lesser-used Unix systems like
# aix or one of the BSDs. If you need to check these, just check the
# current_os value directly.

is_android = current_os == "android"
is_chromeos = current_os == "chromeos"
is_fuchsia = current_os == "fuchsia"
is_ios = current_os == "ios"
is_linux = current_os == "linux"
is_mac = current_os == "mac"
is_nacl = current_os == "nacl"
is_win = current_os == "win" || current_os == "winuwp"

is_apple = is_ios || is_mac
is_posix = !is_win && !is_fuchsia

# =============================================================================
# TARGET DEFAULTS
# =============================================================================
#
# Set up the default configuration for every build target of the given type.
# The values configured here will be automatically set on the scope of the
# corresponding target. Target definitions can add or remove to the settings
# here as needed.
#
# WHAT GOES HERE?
#
# Other than the main compiler and linker configs, the only reason for a config
# to be in this list is if some targets need to explicitly override that config
# by removing it. This is how targets opt-out of flags. If you don't have that
# requirement and just need to add a config everywhere, reference it as a
# sub-config of an existing one, most commonly the main "compiler" one.

# Holds all configs used for running the compiler.
default_compiler_configs = [
  "//build/config:feature_flags",
  "//build/config/compiler:afdo",
  "//build/config/compiler:afdo_optimize_size",
  "//build/config/compiler:cet_shadow_stack",
  "//build/config/compiler:chromium_code",
  "//build/config/compiler:compiler",
  "//build/config/compiler:compiler_arm_fpu",
  "//build/config/compiler:compiler_arm_thumb",
  "//build/config/compiler:default_include_dirs",
  "//build/config/compiler:default_init_stack_vars",
  "//build/config/compiler:default_optimization",
  "//build/config/compiler:default_stack_frames",
  "//build/config/compiler:default_symbols",
  "//build/config/compiler:no_exceptions",
  "//build/config/compiler:no_rtti",
  "//build/config/compiler:no_unresolved_symbols",
  "//build/config/compiler:runtime_library",
  "//build/config/compiler:thin_archive",
  "//build/config/compiler:thinlto_optimize_default",
  "//build/config/compiler/pgo:default_pgo_flags",
  "//build/config/coverage:default_coverage",
  "//build/config/sanitizers:default_sanitizer_flags",
]

if (is_win) {
  default_compiler_configs += [
    "//build/config/win:default_cfg_compiler",
    "//build/config/win:default_crt",
    "//build/config/win:lean_and_mean",
    "//build/config/win:nominmax",
    "//build/config/win:unicode",
    "//build/config/win:winver",
  ]
}

if (is_apple) {
  default_compiler_configs += [ "//build/config/compiler:enable_arc" ]
}

if (is_posix) {
  if (current_os != "aix") {
    default_compiler_configs +=
        [ "//build/config/gcc:symbol_visibility_hidden" ]
  }
}

if (is_fuchsia) {
  default_compiler_configs += [ "//build/config/gcc:symbol_visibility_hidden" ]
}

if (is_android) {
  default_compiler_configs +=
      [ "//build/config/android:default_orderfile_instrumentation" ]
}

if (is_clang && !is_nacl) {
  default_compiler_configs += [
    "//build/config/clang:extra_warnings",
    "//build/config/clang:find_bad_constructs",
    "//build/config/clang:unsafe_buffers",
  ]
}

# Debug/release-related defines.
if (is_debug) {
  default_compiler_configs += [ "//build/config:debug" ]
} else {
  default_compiler_configs += [ "//build/config:release" ]
}

# Static libraries and source sets use only the compiler ones.
set_defaults("static_library") {
  configs = default_compiler_configs
}
set_defaults("source_set") {
  configs = default_compiler_configs
}
set_defaults("rust_library") {
  configs = default_compiler_configs
}

# Compute the set of configs common to all linked targets (shared libraries,
# loadable modules, executables) to avoid duplication below.
if (is_win) {
  # Many targets remove these configs, so they are not contained within
  # //build/config:executable_config for easy removal.
  _linker_configs = [
    "//build/config/win:default_incremental_linking",

    # Default to console-mode apps. Most of our targets are tests and such
    # that shouldn't use the windows subsystem.
    "//build/config/win:console",
  ]
} else if (is_apple) {
  _linker_configs = [ "//build/config/apple:strip_all" ]
} else {
  _linker_configs = []
}

# Executable defaults.
default_executable_configs = default_compiler_configs + [
                               "//build/config/compiler:export_dynamic",
                               "//build/config:default_libs",
                               "//build/config:executable_config",
                             ] + _linker_configs

if (is_win) {
  # Turn on linker CFI for executables, and position it so it can be removed
  # if needed.
  default_executable_configs += [ "//build/config/win:cfi_linker" ]
}
if (is_fuchsia) {
  # Sometimes executables are linked by rustc passing a command line to
  # clang++. It includes "-pie" which is pointless on Fuchsia. Suppress the
  # resulting (fatal) warning. Unfortunately there's no way to do this only
  # for binaries linked by rustc; gn does not make the distinction.
  default_executable_configs +=
      [ "//build/config/fuchsia:rustc_no_pie_warning" ]
}

set_defaults("executable") {
  configs = default_executable_configs
}

# Shared library and loadable module defaults (also for components in component
# mode).
default_shared_library_configs = default_compiler_configs + [
                                   "//build/config:default_libs",
                                   "//build/config:shared_library_config",
                                 ] + _linker_configs
if (is_win) {
  # Turn on linker CFI for DLLs, and position it so it can be removed if needed.
  default_shared_library_configs += [ "//build/config/win:cfi_linker" ]
}

if (is_android) {
  # Strip native JNI exports from shared libraries by default. Binaries that
  # want this can remove this config.
  default_shared_library_configs +=
      [ "//build/config/android:hide_all_but_jni_onload" ]
}
if (is_fuchsia) {
  # Sometimes shared libraries are linked by rustc passing a command line to
  # clang++. It includes "-pie" which is pointless on Fuchsia. Suppress the
  # resulting (fatal) warning. Unfortunately there's no way to do this only
  # for binaries linked by rustc; gn does not make the distinction.
  default_shared_library_configs +=
      [ "//build/config/fuchsia:rustc_no_pie_warning" ]
}
set_defaults("shared_library") {
  configs = default_shared_library_configs
}
set_defaults("loadable_module") {
  configs = default_shared_library_configs

  # loadable_modules are generally used by other libs, not just via JNI.
  if (is_android) {
    configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
  }
}

default_rust_proc_macro_configs =
    default_shared_library_configs + [ "//build/rust:proc_macro_extern" ] +
    # Rust proc macros don't support (Thin)LTO, so always remove it.
    [
      "//build/config/compiler:thinlto_optimize_default",
      "//build/config/compiler:thinlto_optimize_max",
    ] -
    [
      "//build/config/compiler:thinlto_optimize_default",
      "//build/config/compiler:thinlto_optimize_max",
    ]

set_defaults("rust_proc_macro") {
  configs = default_rust_proc_macro_configs
}

# A helper for forwarding testonly and visibility.
# Forwarding "*" does not include variables from outer scopes (to avoid copying
# all globals into each template invocation), so it will not pick up
# file-scoped or outer-template-scoped variables. Normally this behavior is
# desired, but "visibility" and "testonly" are commonly defined in outer scopes.
# Explicitly forwarding them in forward_variables_from() works around this
# nuance. See //build/docs/writing_gn_templates.md#using-forward_variables_from
TESTONLY_AND_VISIBILITY = [
  "testonly",
  "visibility",
]

# Sets default dependencies for static_library and source_set targets.
foreach(_target_type,
        [
          "source_set",
          "static_library",
        ]) {
  template(_target_type) {
    target(_target_type, target_name) {
      forward_variables_from(invoker, "*", TESTONLY_AND_VISIBILITY)
      forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
      if (!defined(inputs)) {
        inputs = []
      }

      # Consumed by the unsafe-buffers plugin during compile.
      #
      # TODO(crbug.com/326584510): Reclient doesn't respect this variable, see
      # rbe_bug_326584510_missing_inputs in //build/config/rbe.gni.
      _uses_cflags = false
      if (defined(sources)) {
        foreach(f, sources) {
          if (string_replace(f + ".END", ".cc.END", "") != f + ".END" ||
              string_replace(f + ".END", ".c.END", "") != f + ".END" ||
              string_replace(f + ".END", ".mm.END", "") != f + ".END" ||
              string_replace(f + ".END", ".m.END", "") != f + ".END") {
            _uses_cflags = true
          }
        }
      }
      if (_uses_cflags && clang_unsafe_buffers_paths != "") {
        inputs += [ clang_unsafe_buffers_paths ]
      }
    }
  }
}

# Sets default dependencies for executable and shared_library targets.
#
# Variables
#   no_default_deps: If true, no standard dependencies will be added.
#       Targets that set this usually also want to remove
#       "//build/config/compiler:runtime_library" from configs (to remove
#       its subconfig "//build/config/c++:runtime_library").
foreach(_target_type,
        [
          "executable",
          "loadable_module",
          "shared_library",
        ]) {
  template(_target_type) {
    # Alias "target_name" because it is clobbered by forward_variables_from().
    _target_name = target_name
    target(_target_type, _target_name) {
      forward_variables_from(invoker,
                             "*",
                             TESTONLY_AND_VISIBILITY + [ "no_default_deps" ])
      forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
      if (!defined(inputs)) {
        inputs = []
      }

      # Consumed by the unsafe-buffers plugin during compile.
      #
      # TODO(crbug.com/326584510): Reclient doesn't respect this variable, see
      # rbe_bug_326584510_missing_inputs in //build/config/rbe.gni.
      _uses_cflags = false
      if (defined(sources)) {
        foreach(f, sources) {
          if (string_replace(f + ".END", ".cc.END", "") != f + ".END" ||
              string_replace(f + ".END", ".c.END", "") != f + ".END" ||
              string_replace(f + ".END", ".mm.END", "") != f + ".END" ||
              string_replace(f + ".END", ".m.END", "") != f + ".END") {
            _uses_cflags = true
          }
        }
      }
      if (_uses_cflags && clang_unsafe_buffers_paths != "") {
        inputs += [ clang_unsafe_buffers_paths ]
      }

      if (!defined(deps)) {
        deps = []
      }
      if (!defined(invoker.no_default_deps) || !invoker.no_default_deps) {
        # This pulls in one of:
        # //build/config:executable_deps
        # //build/config:loadable_module_deps
        # //build/config:shared_library_deps
        # (This explicit list is so that grepping for these configs finds where
        # they are used.)
        deps += [ "//build/config:${_target_type}_deps" ]
      }

      # On Android, write shared library output file to metadata. We will use
      # this information to, for instance, collect all shared libraries that
      # should be packaged into an APK.
      if (!defined(invoker.metadata) && (is_android || is_robolectric) &&
          (_target_type == "shared_library" ||
           _target_type == "loadable_module")) {
        _output_name = _target_name
        if (defined(invoker.output_name)) {
          _output_name = invoker.output_name
        }

        # Remove 'lib' prefix from output name if it exists.
        _magic_prefix = "$0x01$0x01"
        _output_name = string_replace("${_magic_prefix}${_output_name}",
                                      "${_magic_prefix}lib",
                                      _magic_prefix,
                                      1)
        _output_name = string_replace(_output_name, _magic_prefix, "", 1)

        if (defined(output_extension)) {
          _shlib_extension = ".$output_extension"
        } else {
          _shlib_extension = ".so"
        }

        metadata = {
          shared_libraries =
              [ "$root_out_dir/lib${_output_name}${_shlib_extension}" ]
        }
      }
    }
  }
}

# ==============================================================================
# COMPONENT SETUP
# ==============================================================================

# Defines a component, which equates to a shared_library when
# is_component_build == true and a static_library otherwise.
#
# Use static libraries for the static build rather than source sets because
# many of of our test binaries link many large dependencies but often don't
# use large portions of them. The static libraries are much more efficient to
# link in this situation since only the necessary object files are linked.
#
# The invoker can override the type of the target in the non-component-build
# case by setting static_component_type to either "source_set" or
# "static_library". If unset, the default will be used.
template("component") {
  if (is_component_build) {
    _component_mode = "shared_library"

    # Generate a unique output_name for a shared library if not set by invoker.
    if (!defined(invoker.output_name)) {
      _output_name = get_label_info(":$target_name", "label_no_toolchain")
      _output_name =
          string_replace(_output_name, "$target_name:$target_name", target_name)
      _output_name = string_replace(_output_name, "//", "")
      _output_name = string_replace(_output_name, "/", "_")
      _output_name = string_replace(_output_name, ":", "_")
    }
  } else if (defined(invoker.static_component_type)) {
    assert(invoker.static_component_type == "static_library" ||
           invoker.static_component_type == "source_set")
    _component_mode = invoker.static_component_type
  } else if (!defined(invoker.sources) || invoker.sources == []) {
    # When there are no sources defined, use a source set to avoid creating
    # an empty static library (which generally don't work).
    _component_mode = "source_set"
  } else {
    _component_mode = "static_library"
  }
  target(_component_mode, target_name) {
    if (defined(_output_name)) {
      output_name = _output_name
    }
    if (is_component_build && is_android) {
      # By appending .cr, we prevent name collisions with libraries already
      # loaded by the Android zygote.
      output_extension = "cr.so"
    }
    forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
    forward_variables_from(invoker, "*", TESTONLY_AND_VISIBILITY)
  }
}

# Component defaults
# Set a variable since we also want to make this available
# to mixed_component.gni
if (is_component_build) {
  default_component_configs = default_shared_library_configs
  if (is_android) {
    default_component_configs -=
        [ "//build/config/android:hide_all_but_jni_onload" ]
  }
} else {
  default_component_configs = default_compiler_configs
}

set_defaults("component") {
  configs = default_component_configs
}

# =============================================================================
# ACTION OVERRIDE
# =============================================================================
#
# We override gn action() to support remote execution using rewrapper. The
# invoker should set allow_remote to true if remote execution is desired.
#
# As remote execution requires inputs to be made more explicit than is normally
# expected with gn, you may find that setting allow_remote to true will result
# in many missing file errors. In most cases, this should be resolved by
# explicitly declaring these inputs/sources.
#
# However, it may be impractical to determine these inputs in gn. For such
# cases, the invoker can specify a custom input processor, which are currently
# defined and implemented in //build/util/action_remote.py. The appropriate
# value should be set using the custom_processor arg.

# Variables needed by rbe.gni aren't available at the top of this file.
import("//build/toolchain/rbe.gni")
import("//build/toolchain/siso.gni")

# TODO(b/253987456): Add action_foreach support.
foreach(_target_type, [ "action" ]) {
  template(_target_type) {
    forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
    action("${target_name}") {
      forward_variables_from(invoker,
                             [
                               "args",
                               "assert_no_deps",
                               "check_includes",
                               "configs",
                               "data_deps",
                               "data",
                               "depfile",
                               "deps",
                               "metadata",
                               "outputs",
                               "pool",
                               "script",
                               "public_configs",
                               "public_deps",
                               "response_file_contents",
                               "sources",
                               "write_runtime_deps",
                             ])
      allow_remote = false
      if (defined(invoker.allow_remote)) {
        allow_remote = invoker.allow_remote
      }

      # If remote execution is desired, only run remotely when use_remoteexec
      # is enabled, and the environment is not nacl.
      # Siso doesn't use action_remote.py wrapper because it sends requests to
      # Reproxy directly without actions_remote.py/rewrapper.
      # TODO(b/259381924): Investigate enabling in nacl config.
      if (allow_remote && use_remoteexec && !is_nacl && !use_siso) {
        pool = "//build/toolchain:remote_action_pool($default_toolchain)"
        script = "//build/util/action_remote.py"
        inputs = [ invoker.script ]

        re_inputs = [ rebase_path(invoker.script, rbe_exec_root) ]
        if (defined(invoker.inputs)) {
          foreach(input, invoker.inputs) {
            re_inputs += [ rebase_path(input, rbe_exec_root) ]
            inputs += [ input ]
          }
        }
        if (defined(invoker.sources)) {
          foreach(source, invoker.sources) {
            re_inputs += [ rebase_path(source, rbe_exec_root) ]
          }
        }

        re_outputs = []
        if (defined(invoker.outputs)) {
          foreach(output, invoker.outputs) {
            re_outputs += [ rebase_path(output, rbe_exec_root) ]
          }
        }

        # Write input/output lists to files as these can grow extremely large.
        re_inputs_file = "$target_gen_dir/${target_name}__remote_inputs.rsp"
        write_file(re_inputs_file, re_inputs)
        inputs += [ re_inputs_file ]
        re_outputs_file = "$target_gen_dir/${target_name}__remote_outputs.rsp"
        write_file(re_outputs_file, re_outputs)

        rewrapper_cfg = "$rbe_py_cfg_file"
        if (defined(invoker.remote_worker)) {
          remote_worker = invoker.remote_worker
          assert(remote_worker == "large",
                 "remote_worker = " + remote_worker + " is not supported")
          rewrapper_cfg = "$rbe_py_large_cfg_file"
        }

        args = []
        args += [ "$rbe_bin_dir/rewrapper" ]
        if (defined(invoker.custom_processor)) {
          args += [ "--custom_processor=" + invoker.custom_processor ]
        }

        args += [
          "--cfg=" + rewrapper_cfg,
          "--exec_root=$rbe_exec_root",
          "--input_list_paths=" + rebase_path(re_inputs_file, root_build_dir),
          "--output_list_paths=" + rebase_path(re_outputs_file, root_build_dir),
          "python3",
          rebase_path(invoker.script, root_build_dir),
        ]

        if (defined(invoker.args)) {
          args += invoker.args
        }
      } else {
        forward_variables_from(invoker, [ "inputs" ])
        not_needed(invoker,
                   [
                     "custom_processor",
                     "remote_worker",
                   ])
      }
    }
  }
}