BUILD.gn

# Copyright (c) 2017 The Brave Authors. All rights reserved.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at https://mozilla.org/MPL/2.0/.

import(
    "//brave/browser/brave_vpn/win/brave_vpn_wireguard_service/allowlist.gni")
import("//brave/build/config.gni")
import("//brave/components/brave_vpn/common/buildflags/buildflags.gni")
import("//build/config/locales.gni")
import("//build/config/zip.gni")
import("//extensions/buildflags/buildflags.gni")
import("//media/media_options.gni")
import("//third_party/icu/config.gni")
import("//third_party/widevine/cdm/widevine.gni")
import("//tools/grit/repack.gni")
import("//tools/v8_context_snapshot/v8_context_snapshot.gni")
import("//ui/base/ui_features.gni")

if (enable_library_cdms) {
  import("//media/cdm/library_cdm/cdm_paths.gni")
}

if (!is_ios) {
  import("//brave/brave_paks.gni")
}

if (is_mac) {
  import("//brave/build/mac/tweak_info_plist.gni")
  import("//build/config/mac/rules.gni")
}

if (is_win) {
  import("//brave/build/win/sign.gni")
}

if (is_linux) {
  import("//brave/build/linux/channels.gni")
}

declare_args() {
  audit_dev_deps = true
}

if (!is_ios) {
  group("child_dependencies") {
    deps = [
      "common",
      "//brave/renderer",
      "//brave/utility",
    ]
  }

  group("browser_dependencies") {
    deps = [
      "browser",
      "chromium_src/chrome/app",
      "common",
      "//components/omnibox/common",
      "//services/device/public/cpp:device_features",
    ]

    data_deps = [ ":unpacked_resources" ]

    if (!is_ios) {
      deps += [ ":packed_resources" ]
    }
  }

  group("storybook") {
    deps = [ "//brave/.storybook:storybook" ]
  }
}

if (is_win) {
  packed_files_rc_file =
      "$root_out_dir/gen/chrome/installer/mini_installer/packed_delta_files.rc"
  action("delta_installer_archive") {
    script = "//brave/tools/win/create_delta_archive.py"
    if (skip_signing) {
      setup_exe = "setup.exe"
    } else {
      setup_exe = "presigned_binaries/setup.exe"
    }
    inputs = [
      # The original tool for delta archive generation was called "courgette".
      # But it runs out of memory on recent Chromium / Brave revisions. Its
      # drop-in replacement is Zucchini. We need to use its 64-bit version to
      # again prevent out of memory errors.
      "$root_out_dir/zucchini64.exe",
      "$root_out_dir/chrome.7z",
      "$root_out_dir/" + setup_exe,
    ]
    outputs = [
      "$root_out_dir/chrome_patch.diff",
      "$root_out_dir/chrome_patch.packed.7z",
      "$root_out_dir/setup_patch.diff",
      "$root_out_dir/setup_patch.packed.7z",
      packed_files_rc_file,
    ]
    deps = [
      "//chrome/installer/mini_installer:mini_installer_archive",
      "//chrome/installer/setup:setup",
      "//components/zucchini:zucchini64",
    ]
    if (!skip_signing) {
      deps += [ ":signed_setup_exe" ]
    }
    args = [
      "zucchini64.exe",
      "$last_chrome_installer/chrome.7z",
      "chrome.7z",
      "$last_chrome_installer/setup.exe",
      setup_exe,
      "chrome_patch.diff",
      "chrome_patch.packed.7z",
      "setup_patch.diff",
      "setup_patch.packed.7z",
      rebase_path(packed_files_rc_file, root_build_dir),
    ]
    if (is_component_build) {
      args += [ "--is_component_build" ]
    }
  }

  if (!skip_signing) {
    sign("signed_setup_exe") {
      sources = [ "$root_out_dir/setup.exe" ]
      outputs = [ "$root_out_dir/presigned_binaries/setup.exe" ]
      deps = [ "//chrome/installer/setup:setup" ]
    }
    sign("signed_brave_exe") {
      sources = [ "$root_out_dir/brave.exe" ]
      outputs = [ "$root_out_dir/presigned_binaries/brave.exe" ]
      deps = [ "//brave/build/win:copy_exe" ]
    }
    sign("signed_chrome_dll") {
      sources = [ "$root_out_dir/chrome.dll" ]
      outputs = [ "$root_out_dir/presigned_binaries/chrome.dll" ]
      deps = [ "//chrome:chrome_dll" ]
    }
  }

  group("mini_installer_dependencies") {
    deps = [ ":brave" ]
    if (!skip_signing) {
      deps += [
        ":signed_brave_exe",
        ":signed_chrome_dll",
        ":signed_setup_exe",
      ]
      if (enable_widevine && enable_cdm_host_verification) {
        deps += [
          "//brave/browser/widevine:brave_exe_sig",
          "//brave/browser/widevine:chrome_dll_sig",
        ]
      }
    }
  }
}

group("brave") {
  deps = [ "build/$target_os:brave" ]
  if (!is_android && !is_ios) {
    deps += [
      "//brave/components/version_info:generate_version",
      "//chrome",
    ]
  }
}

group("resources") {
  public_deps = [
    # TODO(bridiver)
    # "//brave/browser:resources",
    # "//brave/common:resources",
    # "//brave/renderer:resources",
    "//brave/components/resources",
  ]

  data_deps = [ "//brave/components/resources:about_credits" ]
}

if (is_android) {
  android_assets("brave_file_assets") {
    sources = [
      "//brave/LICENSE.html",
      "//brave/android/java/org/chromium/chrome/browser/ntp/ntp_news_optin_icon_animation.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/onboarding_ads.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/onboarding_ads_notification.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/onboarding_rewards.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/privacy_protection.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/save_data_and_battery.json",
      "//brave/android/java/org/chromium/chrome/browser/onboarding/animations/website_loads_faster.json",
      "//brave/android/java/org/chromium/chrome/browser/shields/disconnect_entitylist.json",
      "//brave/android/java/org/chromium/chrome/browser/vpn/brave_vpn_confirm.json",
    ]
    disable_compression = false
  }

  android_assets("brave_pak_assets") {
    sources = [ "$root_out_dir/brave_resources.pak" ]

    deps = [
      "//brave:brave_file_assets",
      "//brave:packed_resources_extra",
    ]
    disable_compression = true
  }
}

if (is_mac) {
  group("framework_bundle_data") {
    deps = [
      "components/brave_extension/extension/brave_extension:brave_extension_framework_bundle_data",
      "//brave/build/rust:framework_exports",
    ]
  }
}

group("unpacked_resources") {
  if (!is_mac) {
    deps = []
    if (enable_extensions) {
      deps = [
        "//brave/components/brave_extension/extension/brave_extension:locales",
      ]
    }
  }
}

#TODO(bridiver) - what to do
if (!is_ios) {
  group("brave_tests") {
    testonly = true

    deps = [ "test:brave_unit_tests" ]

    if (!is_android) {
      deps += [
        "test:brave_browser_tests",
        "test:brave_network_audit_tests",
      ]
    }
    if (use_libfuzzer) {
      deps += [ "//brave/fuzzers:brave_fuzzers" ]
    }
  }
}

if (!is_ios) {
  brave_paks("packed_resources") {
    if (is_mac) {
      output_dir = "$root_gen_dir/repack"
      copy_data_to_bundle = true
    } else {
      output_dir = root_out_dir
    }
  }
}

branding_dir = "//chrome/app/theme/$branding_path_component"
copy("theme_files") {
  visibility = [ ":*" ]
  if (is_linux) {
    sources = [
      "$branding_dir/linux/product_logo_128_beta.png",
      "$branding_dir/linux/product_logo_128_dev.png",
      "$branding_dir/linux/product_logo_128_development.png",
      "$branding_dir/linux/product_logo_128_nightly.png",
    ]
  } else {
    sources = [
      "$branding_dir/product_logo_128_beta.png",
      "$branding_dir/product_logo_128_dev.png",
      "$branding_dir/product_logo_128_development.png",
      "$branding_dir/product_logo_128_nightly.png",
    ]
  }
  outputs = [ "$root_out_dir/installer/theme/{{source_file_part}}" ]
}

group("create_dist") {
  deps = []
  if (is_android) {
    if (android_aab_to_apk && target_cpu == "arm64") {
      deps += [ "build/android:sign_app_convert_aab_to_apk" ]
    } else {
      deps += [ "build/android:sign_app" ]
    }
  } else {
    deps += [ ":create_symbols_dist" ]
  }

  # for linux zip will be created along with installer
  if (!is_linux) {
    deps += [ ":create_dist_zips" ]
  }

  if (is_win) {
    deps += [
      "//brave/build/win:create_signed_installer",
      "//brave/components/policy:pack_policy_templates",
    ]

    if (build_omaha) {
      deps += [ "//brave/vendor/omaha" ]
    }

    if (build_delta_installer) {
      deps += [ "//brave/build/win:signed_delta_installer" ]
    }
  }
  if (is_mac) {
    if (skip_signing) {
      deps += [ "build/mac:create_dmg" ]
    } else {
      deps += [ "build/mac:finalize_dmg_pkg" ]
    }
  }
  if (is_linux) {
    deps += [
      ":theme_files",
      "//brave/app/linux:dist_resources",
      "//chrome/installer/linux:$linux_channel",
    ]
  }
}

if (!is_mac && !is_android && !is_ios) {
  copy("brave_locale_dist_resources") {
    deps = [ "//chrome:packed_resources" ]

    sources = []
    foreach(locale, platform_pak_locales) {
      sources += [ "$root_out_dir/locales/$locale.pak" ]
    }
    outputs = [ "$brave_dist_dir/locales/{{source_file_part}}" ]
  }

  if (enable_extensions) {
    group("brave_extensions_locale_dist_resources") {
      deps = [
        "//brave/components/brave_extension/extension/brave_extension:locales",
      ]

      public_deps = []
      foreach(locale, platform_pak_locales) {
        # public_deps is used intentionaly because ":create_dist_zip" needs the all dependency
        # of all locale files.
        public_deps += [ ":brave_shields_locales_${locale}" ]
      }
    }

    foreach(locale, platform_pak_locales) {
      copy("brave_shields_locales_${locale}") {
        deps = [ "//brave/components/brave_extension/extension/brave_extension:locales_$locale" ]

        locale = string_replace(locale, "-", "_")
        sources = [ "$root_out_dir/resources/brave_extension/_locales/$locale/messages.json" ]
        outputs = [ "$brave_dist_dir/resources/brave_extension/_locales/$locale/{{source_file_part}}" ]
      }
    }
  }
}

copy("brave_license_dist_resources") {
  sources = [ "//brave/LICENSE" ]

  outputs = [ "$brave_dist_dir/{{source_file_part}}" ]
}

if (!is_android && !is_ios) {
  copy("brave_dist_resources") {
    sources = [ "$root_out_dir/version" ]

    deps = [
      ":brave",
      ":brave_license_dist_resources",
      ":packed_resources",
      "build/$target_os:brave",
      "//brave/components/version_info:generate_version",
      "//chrome:packed_resources",
      "//third_party/icu:icudata",
    ]

    if (!is_mac) {
      sources += [
        "$root_out_dir/$brave_exe",
        "$root_out_dir/brave_100_percent.pak",
        "$root_out_dir/brave_200_percent.pak",
        "$root_out_dir/brave_resources.pak",
        "$root_out_dir/chrome_100_percent.pak",
        "$root_out_dir/chrome_200_percent.pak",
        "$root_out_dir/icudtl.dat",
        "$root_out_dir/resources.pak",
      ]

      if (v8_use_external_startup_data) {
        deps += [ "//v8" ]

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

    outputs = [ "$brave_dist_dir/{{source_file_part}}" ]
  }
}

if (target_cpu == "x86") {
  target_arch = "ia32"
} else {
  target_arch = target_cpu
}

template("create_dist_template") {
  action(target_name) {
    inputs = get_target_outputs(":brave_license_dist_resources")

    file_inputs = []
    foreach(input, inputs) {
      file_inputs += [ rebase_path(input, brave_dist_dir) ]
    }

    rebase_base_dir = rebase_path(brave_dist_dir)

    outputs = [ invoker.output ]
    rebase_output = rebase_path(invoker.output)

    dir_inputs = invoker.dir_inputs

    script = "//brave/script/create-dist.py"

    deps = [ ":brave_license_dist_resources" ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }

    args = [
      "--base-dir=$rebase_base_dir",
      "--inputs=$file_inputs",
      "--dir-inputs=$dir_inputs",
      "--output=$rebase_output",
    ]
  }
}

if (should_generate_symbols) {
  create_dist_template("create_brave_symbols_dist") {
    if (is_android) {
      output = "$brave_dist_dir/$brave_product_name-v$brave_version-$brave_platform-$target_android_base-$target_cpu-symbols-$target_android_output_format.zip"
    } else {
      output = "$brave_dist_dir/$brave_product_name-v$brave_version-$brave_platform-$target_arch-symbols.zip"
    }

    deps = [ "//brave/app/$current_os:symbol_dist_resources" ]

    if (is_win) {
      dir_inputs = [ "$brave_product_name.syms" ]
    } else {
      dir_inputs = [ "$brave_product_name.breakpad.syms" ]
    }
  }

  if (is_mac) {
    copy("create_native_symbols_dist") {
      sources = [ "$root_out_dir/$chrome_product_full_name.dSYM.tar.bz2" ]
      outputs = [ "$brave_dist_dir/$brave_product_name-v$brave_version-$brave_platform-$target_arch-native-symbols.tar.bz2" ]

      deps = [ "//chrome:chrome_dsym_archive" ]
    }
  } else {
    group("create_native_symbols_dist") {
    }
  }
}

group("create_symbols_dist") {
  # Currently on some platforms (Android, Linux) this target generate more
  # than just symbols, so always depend on it.
  public_deps = [ "//brave/app/$current_os:symbol_dist_resources" ]

  if (should_generate_symbols) {
    public_deps += [
      ":create_brave_symbols_dist",
      ":create_native_symbols_dist",
    ]
  }
}

action("create_dist_zips") {
  output = "$brave_dist_dir/$brave_product_name-v$brave_version-$brave_platform-$target_arch.zip"
  outputs = [ output ]

  if (is_win) {
    # Repack a Chrome release archive to the Brave format.
    # Besides changing from 7z to zip, the directory structure is a bit different.
    # TODO(atuchin): support other platforms.

    script = "//brave/script/repack-archive.py"
    deps = [ "//chrome/installer/mini_installer:mini_installer_archive" ]

    input = "$root_out_dir/chrome.7z"
    inputs = [ input ]

    args = [
      "--input=" + rebase_path(input),
      "--output=" + rebase_path(output),
      "--target_dir=Chrome-bin",
    ]
  } else {  # !is_win
    script = "//brave/script/create-dist.py"

    inputs = get_target_outputs(":brave_license_dist_resources")

    if (!is_mac && !is_android && !is_ios) {
      inputs += get_target_outputs(":brave_dist_resources")
      inputs += get_target_outputs(":brave_locale_dist_resources")
      if (enable_extensions) {
        foreach(locale, platform_pak_locales) {
          inputs += get_target_outputs(":brave_shields_locales_${locale}")
        }
      }
    }

    file_inputs = []
    foreach(input, inputs) {
      file_inputs += [ rebase_path(input, brave_dist_dir) ]
    }

    dir_inputs = []
    if (is_mac) {
      dir_inputs += [ "$brave_exe" ]
    }

    deps = [
      ":brave_license_dist_resources",
      "app/$current_os:dist_resources",
    ]

    if (!is_mac && !is_android && !is_ios) {
      deps += [
        ":brave_dist_resources",
        ":brave_locale_dist_resources",
      ]

      if (enable_extensions) {
        deps += [ ":brave_extensions_locale_dist_resources" ]
      }
    }

    rebase_output = rebase_path(output)
    if (is_mac) {
      rebase_base_dir = rebase_path(root_out_dir)
    } else {
      rebase_base_dir = rebase_path(brave_dist_dir, root_out_dir)
    }
    args = [
      "--base-dir=$rebase_base_dir",
      "--inputs=$file_inputs",
      "--dir-inputs=$dir_inputs",
      "--output=$rebase_output",
    ]
  }  # !is_win
}

if (is_mac) {
  group("brave_app") {
    deps = [ ":brave_app_plist" ]
  }

  brave_tweak_info_plist("brave_app_plist") {
    info_plist = "$root_gen_dir/chrome/chrome_app_plist_tweaked.plist"

    args = [
      "--brave_channel=" + brave_channel,
      "--brave_product_dir_name=" + brave_product_dir_name,
      "--brave_version=" + brave_version,
      "--brave_eddsa_key=" + sparkle_eddsa_public_key,
    ]

    if (skip_signing) {
      args += [ "--skip_signing" ]
    }

    deps = [ "//chrome:chrome_app_plist" ]
  }

  brave_tweak_info_plist("brave_helper_plist") {
    info_plist = "$root_gen_dir/chrome/chrome_helper_plist_tweaked.plist"

    args = [
      "--brave_channel=" + brave_channel,
      "--brave_product_dir_name=" + brave_product_dir_name,
      "--brave_version=" + brave_version,
    ]

    deps = [ "//chrome:chrome_helper_plist" ]
  }
}

cargo_audit_target_dir = "$root_build_dir/cargo_audit"
cargo_audit_exe = "$cargo_audit_target_dir/release/cargo-audit"
cargo_audit_src = "//brave/tools/crates/cargo_audit/v0_20/crate"
if (host_os == "win") {
  cargo_audit_exe += ".exe"
}

action("build_cargo_audit") {
  script = "//build/gn_run_binary.py"

  cargo_exe = "//third_party/rust-toolchain/bin/cargo"
  if (host_os == "win") {
    cargo_exe += ".exe"
  }

  inputs = [
    cargo_exe,
    "$cargo_audit_src/Cargo.lock",
  ]
  outputs = [ cargo_audit_exe ]
  args = [
    rebase_path(cargo_exe),
    "build",
    "--release",
    "--manifest-path",
    rebase_path("$cargo_audit_src/Cargo.toml"),
    "--target-dir",
    rebase_path(cargo_audit_target_dir),
  ]
}

action("audit_deps") {
  script = "//brave/script/audit_deps.py"

  outputs = [ "$root_gen_dir/non-existent-audit_deps" ]

  args = [
    "--source_root=" + rebase_path("//brave"),
    "--cargo_audit_exe=" + rebase_path(cargo_audit_exe),
  ]

  if (audit_dev_deps) {
    args += [ "--audit_dev_deps" ]
  }

  deps = [ ":build_cargo_audit" ]
}

if (is_redirect_cc_build) {
  group("redirect_cc") {
    deps = [ "//brave/tools/redirect_cc" ]
  }
}
if (is_win && enable_resource_allowlist_generation) {
  # Merge chrome_resource_allowlist and wireguard resources allowlist to keep
  # wireguard resources in pak files.
  action("merge_allowlists") {
    deps = [
      "//brave/browser/brave_vpn/win/brave_vpn_wireguard_service:wireguard_resource_allowlist",
      "//chrome:resource_allowlist",
    ]

    script = "//brave//resources/brave_allowlist.py"
    source_allowlist = "$root_gen_dir/chrome/chrome_resource_allowlist.txt"
    args = [
      "--repack_allowlist",
      rebase_path(source_allowlist, root_build_dir),
      "--brave_allowlist",
      rebase_path(wireguard_resource_allowlist_file, root_build_dir),
      "--output",
      rebase_path(brave_allowlist_file, root_build_dir),
    ]

    outputs = [ brave_allowlist_file ]
  }
}