BUILD.gn

import("//build/buildflag_header.gni")
import("//build/config/chrome_build.gni")
import("//build/config/compiler/compiler.gni")
import("//build/config/features.gni")
import("//build/config/locales.gni")
import("//build/config/crypto.gni")
import("//build/config/sanitizers/sanitizers.gni")
import("//build/config/ui.gni")
import("//build/config/zip.gni")
import("//build/util/branding.gni")
import("//build/util/process_version.gni")
import("//extensions/features/features.gni")
import("//ppapi/features/features.gni")
import("//printing/features/features.gni")
import("//tools/grit/grit_rule.gni")
import("//tools/grit/repack.gni")
import("//ui/base/ui_features.gni")
import("//v8/gni/v8.gni")
import("//third_party/icu/config.gni")
import("//media/cdm/ppapi/cdm_paths.gni")
import("//electron/build/config.gni")

group("electron") {
  testonly = false

  if (is_mac) {
    public_deps = [
      "app/mac:electron_app",
    ]

    data_deps = [
      "app/mac:electron_app",
    ]
  }

  if (is_linux) {
    public_deps = [
      "app/linux:electron_app",
    ]

    data_deps = [
      "app/linux:electron_app",
    ]
  }

  if (is_win) {
    public_deps = [
      "app/win:electron_app",
    ]

    data_deps = [
      "app/win:electron_app",
    ]
  }

  if (use_aura && (is_win || is_linux)) {
    data_deps += [ "app:service_manifests" ]
  }
}

grit("atom_resources") {
  source = "atom/atom_resources.grd"
  output_dir = "$root_gen_dir/atom/"
  outputs = [
    "grit/atom_resources.h",
    "atom_resources.pak",
  ]

  resource_ids = "//electron/resource_ids"
}

grit("brave_resources") {
  source = "brave/brave_resources.grd"
  output_dir = "$root_gen_dir/brave/"
  outputs = [
    "grit/brave_resources.h",
    "brave_resources.pak",
  ]

  grit_flags = [
    "-E",
    "root_gen_dir=" + rebase_path(root_gen_dir),
  ]

  deps = [
    "app:brave_content_manifest_overlays",
  ]

  resource_ids = "//electron/resource_ids"
}

grit("electron_api_resources") {
  source = "lib/electron_api_resources.grd"
  output_dir = "$root_gen_dir/atom/"
  outputs = [
    "grit/electron_api_resources.h",
    "electron_api_resources.pak",
  ]

  resource_ids = "//electron/resource_ids"
}

group("packed_resources") {
  public_deps = [
    ":packed_extra_resources",
    "//chrome:packed_resources",
  ]
}

repack("packed_extra_resources") {
  visibility = [ "./*" ]
  sources = [
    "$root_gen_dir/atom/atom_resources.pak",
    "$root_gen_dir/brave/brave_resources.pak",
    "$root_gen_dir/brave/brave_strings.pak",
    "$root_gen_dir/chrome/common_resources.pak",
    "$root_gen_dir/blink/public/resources/blink_resources.pak",
    "$root_gen_dir/content/app/strings/content_strings_en-US.pak",
    "$root_gen_dir/content/browser/tracing/tracing_resources.pak",
    "$root_gen_dir/content/content_resources.pak",
    "$root_gen_dir/net/net_resources.pak",
    "$root_gen_dir/ui/resources/webui_resources.pak",
    "$root_gen_dir/ui/strings/app_locale_settings_en-US.pak",
    "$root_gen_dir/ui/strings/ui_strings_en-US.pak",
    "$root_gen_dir/components/components_resources.pak",
    "$root_gen_dir/content/browser/devtools/devtools_resources.pak",
  ]

  deps = [
    ":atom_resources",
    ":brave_resources",
    "app:brave_strings",
    "//chrome/common:resources",
    "//chrome/renderer:resources",
    "//content:resources",
    "//content/app/resources",
    "//content/app/strings",
    "//content/browser/tracing:resources",
    "//net:net_resources",
    "//third_party/WebKit/public:image_resources",
    "//third_party/WebKit/public:resources",
    "//ui/resources",
    "//ui/strings",
    "//content/browser/devtools:resources",
    "//components/resources:components_resources",
    "//content/browser/devtools:devtools_resources",
  ]

  if (enable_extensions) {
    sources += [
      "$root_gen_dir/atom/electron_api_resources.pak",
      "$root_gen_dir/extensions/extensions_renderer_resources.pak",
      "$root_gen_dir/extensions/extensions_resources.pak",
    ]
    deps += [
      ":electron_api_resources",
      "//extensions:extensions_resources"
    ]
  }

  if (is_mac) {
    output = "$root_gen_dir/repack/electron_resources.pak"
  } else {
    output = "$root_out_dir/electron_resources.pak"
  }
}

source_set("browser_dependencies") {
  public_configs = [
    "build:electron_config",
  ]

  public_deps = [
    "atom/app",
    "brave/browser",
    ":common",
    "lib:atom_js2c",
  ]

  sources = []

  if (enable_plugins) {
    public_deps += [ "//ppapi/host" ]
  }

  if (enable_basic_printing || enable_print_preview) {
    public_deps += [ "//printing" ]
  }
}

group("child_dependencies") {
  public_deps = [
    "atom/app",
    ":common",
    ":renderer",
    ":utility",
    "//base",
    "//content/public/child",
    "//third_party/WebKit/public:blink_devtools_frontend_resources",
  ]
  if (use_aura) {
    public_deps += [ "//ui/views/mus" ]
  }
}

source_set("common") {
  public_deps = [ "atom/common" ]

  sources = [
    "brave/common/extensions/asar_source_map.cc",
    "brave/common/extensions/asar_source_map.h",
    "brave/common/extensions/crash_reporter_bindings.cc",
    "brave/common/extensions/crash_reporter_bindings.h",
    "brave/common/extensions/file_bindings.cc",
    "brave/common/extensions/file_bindings.h",
    "brave/common/extensions/path_bindings.cc",
    "brave/common/extensions/path_bindings.h",
    "brave/common/extensions/shared_memory_bindings.cc",
    "brave/common/extensions/shared_memory_bindings.h",
    "brave/common/extensions/url_bindings.cc",
    "brave/common/extensions/url_bindings.h",
    "brave/common/importer/imported_cookie_entry.h",
    "brave/common/workers/worker_bindings.cc",
    "brave/common/workers/worker_bindings.h",
    "brave/common/workers/v8_worker_thread.cc",
    "brave/common/workers/v8_worker_thread.h",
  ]

  deps = [
    "chromium_src:common",
    ":electron_version_header",
    "//base",
    "//components/url_formatter",
    "//content/public/child",
  ]

  if (enable_extensions) {
    public_deps += [
      "brave/common/extensions/api",
    ]
  }
}

source_set("utility") {
  public_configs = [
    "build:electron_config",
  ]

  public_deps = [
    "//content/public/common",
  ]

  defines = [ ]

  deps = [
    "chromium_src:importer",
    "//chrome/common",
    "//chrome/utility",
    "//components/cookie_config",
    "//services/proxy_resolver:lib",
    "//third_party/protobuf:protobuf_lite",
  ]

  if (use_glib) {
    defines += [ "USE_LIBSECRET" ]
    deps += [ "//third_party/libsecret" ]
  }

  sources = [
    "atom/utility/atom_content_utility_client.cc",
    "atom/utility/atom_content_utility_client.h",
    "brave/utility/importer/chrome_importer.cc",
    "brave/utility/importer/chrome_importer.h",
    "brave/utility/importer/brave_external_process_importer_bridge.cc",
    "brave/utility/importer/brave_external_process_importer_bridge.h",
    "brave/utility/importer/brave_profile_import_impl.cc",
    "brave/utility/importer/brave_profile_import_impl.h",
    "brave/utility/importer/brave_profile_import_service.cc",
    "brave/utility/importer/brave_profile_import_service.h",
    "brave/utility/importer/firefox_importer.cc",
    "brave/utility/importer/firefox_importer.h",
    "brave/utility/importer/importer_creator.cc",
    "brave/utility/importer/importer_creator.h",
  ]
}

source_set("renderer") {
  public_configs = [
    "build:electron_config",
  ]

  sources = [
    "atom/renderer/content_settings_manager.cc",
    "atom/renderer/content_settings_manager.h",
    "brave/renderer/brave_content_renderer_client.cc",
    "brave/renderer/brave_content_renderer_client.h",
  ]

  public_deps = [
    "//chrome/renderer",
  ]

  deps = [
    "chromium_src:renderer",
    ":common",
    "//third_party/WebKit/public:blink_headers",
  ]

  data_deps = [
    ":atom_resources",
    ":brave_resources",
    ":electron_api_resources",
  ]

  if (enable_basic_printing) {
    sources += [
      "brave/renderer/printing/brave_print_render_frame_helper_delegate.cc",
      "brave/renderer/printing/brave_print_render_frame_helper_delegate.h",
    ]

    deps += [
      "//components/printing/renderer",
    ]
  }

  if (enable_extensions) {
    sources += [
      # TODO(bridiver) - change to brave/renderer/extensions
      "atom/common/javascript_bindings.cc",
      "atom/common/javascript_bindings.h",
      "brave/renderer/extensions/content_settings_bindings.cc",
      "brave/renderer/extensions/content_settings_bindings.h",
      "brave/renderer/extensions/web_frame_bindings.cc",
      "brave/renderer/extensions/web_frame_bindings.h",
    ]

    deps += [
      ":common",
      "//extensions:extensions_resources",
      "//extensions/renderer",
      "//media/cast:net",
      "//media/cast:receiver",
      "//media/cast:sender",
    ]
  }
}

source_set("native_mate") {
  configs += [
    "build:electron_config",
  ]

  sources = [
    "vendor/native_mate/native_mate/arguments.cc",
    "vendor/native_mate/native_mate/arguments.h",
    "vendor/native_mate/native_mate/compat.h",
    "vendor/native_mate/native_mate/constructor.h",
    "vendor/native_mate/native_mate/converter.cc",
    "vendor/native_mate/native_mate/converter.h",
    "vendor/native_mate/native_mate/dictionary.cc",
    "vendor/native_mate/native_mate/dictionary.h",
    "vendor/native_mate/native_mate/function_template.cc",
    "vendor/native_mate/native_mate/function_template.h",
    "vendor/native_mate/native_mate/handle.h",
    "vendor/native_mate/native_mate/object_template_builder.cc",
    "vendor/native_mate/native_mate/object_template_builder.h",
    "vendor/native_mate/native_mate/persistent_dictionary.cc",
    "vendor/native_mate/native_mate/persistent_dictionary.h",
    "vendor/native_mate/native_mate/scoped_persistent.h",
    "vendor/native_mate/native_mate/template_util.h",
    "vendor/native_mate/native_mate/try_catch.cc",
    "vendor/native_mate/native_mate/try_catch.h",
    "vendor/native_mate/native_mate/wrappable.cc",
    "vendor/native_mate/native_mate/wrappable.h",
    "vendor/native_mate/native_mate/wrappable_base.h",
  ]

  deps = [
    "build/node",
    "//third_party/WebKit/public:blink_headers",
  ]
}

electron_framework_sources = []

if (!is_mac) {
  electron_framework_sources += [
    "$root_out_dir/chrome_100_percent.pak",
  ]

  if (enable_hidpi) {
    electron_framework_sources += [
      "$root_out_dir/chrome_200_percent.pak",
    ]
  }
}

electron_framework_public_deps = [
  ":packed_resources",
]

if (icu_use_data_file) {
  electron_framework_sources += [
    "$root_out_dir/icudtl.dat"
  ]
  electron_framework_public_deps += [
    "//third_party/icu:icudata"
  ]
}

if (v8_use_external_startup_data) {
  electron_framework_sources += [
    "$root_out_dir/natives_blob.bin",
    "$root_out_dir/snapshot_blob.bin",
  ]
  electron_framework_public_deps += [ "//v8:v8" ]
}

electron_app_sources = [
  "$root_out_dir/electron.asar",
  "$root_out_dir/default_app.asar",
]

electron_app_public_deps = [
  "//electron/lib",
  "//electron/default_app",
]

if (is_mac) {
  electron_app_sources += [
    "//electron/app/resources/$electron_icon_dir/brave.icns",
  ]
}

if (is_mac) {
  bundle_data("electron_framework_resources") {
    sources = electron_framework_sources
    sources += [
      "$root_gen_dir/repack/electron_resources.pak",
    ]
    public_deps = electron_framework_public_deps

    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
  }
} else {
  group("electron_framework_resources") {
    public_deps = electron_framework_public_deps
  }
}

if (is_mac) {
  bundle_data("electron_app_resources") {
    sources = electron_app_sources
    public_deps = electron_app_public_deps

    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
  }
} else {
  copy("electron_app_resources") {
    sources = electron_app_sources
    public_deps = electron_app_public_deps

    outputs = [
      "$root_out_dir/resources/{{source_file_part}}"
    ]
  }
}

process_version("electron_version_header") {
  sources = []
  template_file = "app/resources/atom_version.h.in"
  extra_args = [
    "-e", "MAJOR=$electron_version_major",
    "-e", "MINOR=$electron_version_minor",
    "-e", "BUILD=$electron_version_build",
  ]

  output = "$target_gen_dir/atom/common/atom_version.h"
}

action("generate_version") {
  script = "//electron/script/version.py"

  outputs = [
    "$root_out_dir/version"
  ]
}

action("generate_chromium_licenses") {
  license_file = "$root_gen_dir/LICENSES.chromium.html"

  script = "//tools/licenses.py"

  inputs = [
    rebase_path("//electron/resources/about_credits.tmpl"),
    rebase_path("//electron/resources/about_credits_entry.tmpl"),
  ]

  outputs = [
    license_file
  ]

  args = [
    "--target-os=$target_os",
    "credits",
    rebase_path(license_file, root_build_dir),
  ]
}

copy("electron_license_dist_resources") {
  sources = get_target_outputs(":generate_chromium_licenses")
  sources += [
    "//electron/LICENSE",
  ]
  deps = [
    ":generate_chromium_licenses",
  ]

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

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

chromedriver = "chromedriver"
if (is_win) {
  chromedriver = "$chromedriver.exe"
}

chromedriver_version = "2.33"

copy("electron_chromedriver_dist_resources") {
  sources = [
    "$root_out_dir/$chromedriver",
  ]

  outputs = [
    "$electron_dist_dir/$chromedriver"
  ]

  deps = [ "//chrome/test/chromedriver:chromedriver" ]
}

zip("chromedriver_zip") {
  inputs = get_target_outputs(":electron_chromedriver_dist_resources")
  inputs += get_target_outputs(":electron_license_dist_resources")
  output = "$electron_dist_dir/chromedriver-v$chromedriver_version-$electron_platform-$target_arch.zip"

  base_dir = electron_dist_dir

  deps = [
    "app/$current_os:chromedriver_dist_resources",
    ":electron_chromedriver_dist_resources",
    ":electron_license_dist_resources",
  ]
}

if (!is_mac) {
  copy("electron_app_dist_resources") {
    sources = get_target_outputs(":electron_app_resources")

    deps = [
      ":electron_app_resources",
    ]

    outputs = [
      "$electron_dist_dir/resources/{{source_file_part}}"
    ]
  }
}

copy("electron_dist_resources") {
  if (is_mac) {
    sources = []
  } else {
    sources = electron_framework_sources
    sources += [
      "$root_out_dir/electron_resources.pak",
      "$root_out_dir/$electron_exe"
    ]
  }

  sources += get_target_outputs(":generate_version")

  deps = electron_framework_public_deps
  deps += [
    ":electron",
    ":generate_version",
  ]

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

if (!is_mac) {
  copy("electron_locale_dist_resources") {
    deps = [
      "//chrome:packed_resources",
    ]

    sources = []
    foreach(locale, locales) {
      # print (locale)
      if (is_mac) {
        sources += [ "$root_gen_dir/repack/locales/$locale.pak" ]
      } else {
        sources += [ "$root_out_dir/locales/$locale.pak" ]
      }
    }
    outputs = [
      "$electron_dist_dir/locales/{{source_file_part}}",
    ]
  }
}

action("create_symbols_dist") {
  output = "$electron_dist_dir/$electron_project_name-v$electron_version-$electron_platform-$target_arch-symbols.zip"

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

  # inputs = get_target_outputs(":electron_chromedriver_dist_resources")
  inputs = get_target_outputs(":electron_license_dist_resources")
  dir_inputs = [ "$electron_project_name.breakpad.syms" ]

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

  rebase_output = rebase_path(output)
  rebase_base_dir = rebase_path(electron_dist_dir)

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

  outputs = [ output ]

  deps = [
    "app/$current_os:symbol_dist_resources",
    ":electron_license_dist_resources",
  ]
}

action("create_dist") {
  output = "$electron_dist_dir/$electron_project_name-v$electron_version-$electron_platform-$target_arch.zip"

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

  inputs = get_target_outputs(":electron_license_dist_resources")

  if (!is_mac) {
    inputs += get_target_outputs(":electron_dist_resources")
    inputs += get_target_outputs(":electron_app_dist_resources")
    inputs += get_target_outputs(":electron_locale_dist_resources")
  }

  if (is_win) {
    inputs += [
      "$electron_dist_dir/chrome_elf.dll",
      "$electron_dist_dir/xinput1_3.dll",
      "$electron_dist_dir/libEGL.dll",
      "$electron_dist_dir/libGLESv2.dll",
      "$electron_dist_dir/d3dcompiler_47.dll",
      "$electron_dist_dir/$widevine_cdm_path/widevinecdmadapter.dll",
    ]
  }

  dist_dir = electron_dist_dir

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

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

  outputs = [
    output
  ]

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

  deps += [ ":chromedriver_zip" ]

  if (!is_mac) {
    deps += [
      ":electron_dist_resources",
      ":electron_app_dist_resources",
      ":electron_locale_dist_resources",
    ]
  }
  if (is_win) {
    deps += [
      "app/win:dist_widevine_resources",
    ]
  }

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