path: root/chromium/chrome/installer/mini_installer/BUILD.gn

# 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/compiler/compiler.gni")
import("//build/config/features.gni")
import("//build/config/ui.gni")
import("//chrome/process_version_rc_template.gni")
import("//chrome/test/mini_installer/mini_installer_test.gni")
import("//components/nacl/features.gni")
import("//third_party/icu/config.gni")
import("//tools/v8_context_snapshot/v8_context_snapshot.gni")
import("//ui/base/ui_features.gni")
import("//v8/gni/v8.gni")

declare_args() {
  # The Chrome archive is compressed in official builds to reduce the size of
  # the installer. By default: non-official or component builds, a build mode
  # targeting developers, do not compress so as to provide quicker build-test
  # cycles.
  skip_archive_compression = !is_official_build || is_component_build
}

config("mini_installer_compiler_flags") {
  # Disable buffer security checking.
  cflags = [ "/GS-" ]
}

source_set("lib") {
  sources = [
    "appid.h",
    "chrome.release",
    "chrome_appid.cc",
    "configuration.cc",
    "configuration.h",
    "decompress.cc",
    "decompress.h",
    "mini_installer.cc",
    "mini_installer.h",
    "mini_installer.rc",
    "mini_installer_constants.cc",
    "mini_installer_constants.h",
    "mini_installer_resource.h",
    "mini_string.cc",
    "mini_string.h",
    "pe_resource.cc",
    "pe_resource.h",
    "regkey.cc",
    "regkey.h",
  ]

  if (skip_archive_compression) {
    defines = [ "SKIP_ARCHIVE_COMPRESSION" ]
  }

  configs += [ ":mini_installer_compiler_flags" ]

  # This input dependency on the mini installer test Python files will force a
  # recompilation when any of the Python files have changed. This will then
  # invalidate the build and trigger running the test on the bots even when
  # no other Chrome files have changed. These have to be inputs rather than a
  # dependency because a dependency won't actually trigger recompiles in
  # incremental build cases unless a source file actually references one of the
  # dependency outputs.
  inputs = mini_installer_test_files
}

process_version_rc_template("version") {
  template_file = "mini_installer_exe_version.rc.version"
  output = "$root_out_dir/mini_installer_exe_version.rc"
}

source_set("unit_tests") {
  testonly = true

  sources = [
    "configuration_test.cc",
    "decompress_test.cc",
    "mini_installer_unittest.cc",
    "mini_string_test.cc",
  ]

  public_deps = [
    ":lib",
  ]
  deps = [
    "//base",
    "//base/test:test_support",
    "//chrome/install_static:install_static_util",
    "//chrome/installer/util:with_no_strings",
    "//testing/gtest",
  ]
}

# The runtime deps are used to tell create_installer_archive what component
# DLLs need to be packaged in a component build.
chrome_runtime_deps = "$root_gen_dir/chrome_component.runtime_deps"
setup_runtime_deps = "$root_gen_dir/setup.runtime_deps"

group("chrome_runtime_deps") {
  write_runtime_deps = chrome_runtime_deps
  data_deps = [
    "//chrome",
  ]
}

group("setup_runtime_deps") {
  write_runtime_deps = setup_runtime_deps
  data_deps = [
    "//chrome/installer/setup",
  ]
}

# Generates a mini installer.
#
#   out_dir (required)
#     The output directory out_dir where the mini_installer image should be
#     written.
#
#   chrome_dll_file (required)
#     The path to the version of chrome.dll that should be included in the
#     installer archive.
#
#   chrome_dll_target (required)
#     The target that generated chrome_dll_file.
#
#   deps (required)
#     Normal meaning.
template("generate_mini_installer") {
  chrome_dll_file = invoker.chrome_dll_file
  chrome_dll_target = invoker.chrome_dll_target
  output_dir = invoker.out_dir

  packed_files_rc_file = "$target_gen_dir/$target_name/packed_files.rc"
  archive_name = target_name + "_archive"
  staging_dir = "$target_gen_dir/$target_name"

  action(archive_name) {
    script = "//chrome/tools/build/win/create_installer_archive.py"

    release_file = "chrome.release"

    inputs = [
      "$chrome_dll_file",
      "$root_out_dir/chrome.exe",
      "$root_out_dir/locales/en-US.pak",
      "$root_out_dir/setup.exe",
      "//chrome/tools/build/win/makecab.py",
      release_file,
    ]

    outputs = [
      # See also chrome.packed.7z conditionally added below.
      "$output_dir/chrome.7z",
      "$output_dir/setup.ex_",
      packed_files_rc_file,
    ]
    args = [
      "--build_dir",
      rebase_path(root_out_dir, root_build_dir),
      "--staging_dir",
      rebase_path(staging_dir, root_build_dir),
      "--input_file",
      rebase_path(release_file, root_build_dir),
      "--resource_file_path",
      rebase_path(packed_files_rc_file, root_build_dir),
      "--target_arch=$current_cpu",
      "--distribution=_google_chrome",
      "--output_dir",
      rebase_path(output_dir, root_build_dir),
      "--chrome_runtime_deps",
      rebase_path(chrome_runtime_deps, root_build_dir),
      "--setup_runtime_deps",
      rebase_path(setup_runtime_deps, root_build_dir),

      # Optional arguments to generate diff installer.
      #'--last_chrome_installer=C:/Temp/base',
      #'--setup_exe_format=DIFF',
      #'--diff_algorithm=COURGETTE',

      # Optional argument for verbose archiving output.
      #'--verbose',
    ]

    deps = [
      ":chrome_runtime_deps",
      ":setup_runtime_deps",
      "//chrome",
      "//chrome/browser/extensions/default_extensions",
      "//chrome/installer/setup",
      "//third_party/icu:icudata",
      chrome_dll_target,
    ]

    if (enable_hidpi) {
      args += [ "--enable_hidpi=1" ]
    }
    if (is_component_build) {
      args += [ "--component_build=1" ]
    }

    if (skip_archive_compression) {
      args += [ "--skip_archive_compression" ]
    } else {
      outputs += [ "$output_dir/chrome.packed.7z" ]
    }

    if (enable_nacl) {
      inputs += [ "$root_out_dir/nacl_irt_x86_64.nexe" ]
      deps += [ "//ppapi/native_client:irt" ]
      if (current_cpu == "x86") {
        inputs += [
          "$root_out_dir/nacl64.exe",
          "$root_out_dir/nacl_irt_x86_32.nexe",
        ]
        deps += [ "//components/nacl/broker:nacl64" ]
      }
    }

    if (icu_use_data_file) {
      inputs += [ "$root_out_dir/icudtl.dat" ]
    } else {
      inputs += [ "$root_out_dir/icudt.dll" ]
    }

    if (v8_use_external_startup_data) {
      inputs += [ "$root_out_dir/natives_blob.bin" ]
      deps += [ "//v8" ]
      if (use_v8_context_snapshot) {
        inputs += [ "$root_out_dir/v8_context_snapshot.bin" ]
        deps += [ "//tools/v8_context_snapshot" ]
      } else {
        inputs += [ "$root_out_dir/snapshot_blob.bin" ]
      }
    }

    depfile = "$target_gen_dir/archive.d"
    args += [
      "--depfile",
      rebase_path(depfile, root_build_dir),
    ]
  }

  executable(target_name) {
    output_name = "mini_installer"
    sources = [
      "mini_installer_exe_main.cc",
      packed_files_rc_file,
    ]

    # This target is special so we manually override most linker flags and
    # specify our own to keep the size down. Also make sure that we don't use
    # WPO as it's not supported by the mini installer.
    configs -= [
      "//build/config/compiler:default_optimization",
      "//build/config:executable_config",
      "//build/config/win:console",
    ]
    configs += [
      ":mini_installer_compiler_flags",
      "//build/config/compiler:optimize_no_wpo",
      "//build/config/sanitizers:link_executable",
      "//build/config/win:sdk_link",
      "//build/config/win:windowed",
    ]

    ldflags = [
      "/FIXED:NO",
      "/ignore:4199",
      "/NXCOMPAT",
    ]

    if (!is_asan) {
      ldflags += [ "/ENTRY:MainEntryPoint" ]
    }

    libs = [ "setupapi.lib" ]

    deps = [
      ":$archive_name",
      ":lib",
      ":version",
      "//build/config:exe_and_shlib_deps",
      "//build/win:default_exe_manifest",
    ]
  }
}

generate_mini_installer("mini_installer") {
  out_dir = root_out_dir
  chrome_dll_file = "$root_out_dir/chrome.dll"
  chrome_dll_target = "//chrome:main_dll"
}

if (is_syzyasan) {
  generate_mini_installer("mini_installer_syzygy") {
    out_dir = "$root_out_dir/syzygy/"
    chrome_dll_file = "$root_out_dir/syzygy/chrome.dll"
    chrome_dll_target = "//chrome/tools/build/win/syzygy:chrome_dll_syzygy"
  }
}

# next_version_mini_installer.exe can't be generated in an x86 Debug component
# build because it requires too much memory.
# TODO(thakis): Enable this in cross builds, https://crbug.com/799827
if (!(is_component_build && is_debug && target_cpu == "x86") &&
    host_os == "win") {
  action("next_version_mini_installer") {
    script = "generate_next_version_mini_installer.py"
    testonly = true
    inputs = [
      "$root_out_dir/alternate_version_generator.exe",
      "$root_out_dir/mini_installer.exe",
    ]
    outputs = [
      "$root_out_dir/$target_name.exe",
    ]
    args = [
      "--out",
      "$target_name.exe",
    ]
    deps = [
      ":mini_installer",
      "//chrome/installer/test:alternate_version_generator",
    ]
  }
}

if (is_win) {
  group("mini_installer_tests") {
    testonly = true
    data_deps = [
      ":mini_installer",
      ":next_version_mini_installer",
    ]
  }
}