BUILD.gn

import("//build/config/locales.gni")
import("//build/config/ui.gni")
import("//build/config/win/manifest.gni")
import("//pdf/features.gni")
import("//services/service_manager/public/service_manifest.gni")
import("//third_party/ffmpeg/ffmpeg_options.gni")
import("//tools/generate_library_loader/generate_library_loader.gni")
import("//tools/grit/grit_rule.gni")
import("//tools/grit/repack.gni")
import("//tools/v8_context_snapshot/v8_context_snapshot.gni")
import("//v8/snapshot_toolchain.gni")
import("build/asar.gni")
import("build/npm.gni")
import("build/tsc.gni")
import("buildflags/buildflags.gni")
import("electron_paks.gni")
import("filenames.auto.gni")
import("filenames.gni")

if (is_mac) {
  import("//build/config/mac/rules.gni")
  import("//third_party/icu/config.gni")
  import("//v8/gni/v8.gni")
}

if (is_linux) {
  import("//build/config/linux/pkg_config.gni")

  pkg_config("gio_unix") {
    packages = [ "gio-unix-2.0" ]
  }

  pkg_config("libnotify_config") {
    packages = [
      "glib-2.0",
      "gdk-pixbuf-2.0",
    ]
  }
}

branding = read_file("atom/app/BRANDING.json", "json")
electron_project_name = branding.project_name
electron_product_name = branding.product_name
electron_mac_bundle_id = branding.mac_bundle_id

if (is_mas_build) {
  assert(is_mac,
         "It doesn't make sense to build a MAS build on a non-mac platform")
}

config("branding") {
  defines = [
    "ATOM_PRODUCT_NAME=\"$electron_product_name\"",
    "ATOM_PROJECT_NAME=\"$electron_project_name\"",
  ]
}

# We geneate the definitions twice here, once in //electron/electron.d.ts
# and once in $target_gen_dir
# The one in $target_gen_dir is used for the actual TSC build later one
# and the one in //electron/electron.d.ts is used by your IDE (vscode)
# for typescript prompting
npm_action("build_electron_definitions") {
  script = "gn-typescript-definitions"
  args = [ rebase_path("$target_gen_dir/tsc/typings/electron.d.ts") ]
  inputs = auto_filenames.api_docs + [ "package-lock.json" ]

  outputs = [
    "$target_gen_dir/tsc/typings/electron.d.ts",
  ]
}

npm_action("atom_browserify_sandbox") {
  script = "browserify"
  deps = [
    ":build_electron_definitions",
  ]

  inputs = [
    # FIXME(zcbenz): The dependencies of these files are not listed here, so
    # the generated file will be out-dated when dependencies are modified.
    # Use a script to generate all dependencies and put them here.
    "lib/sandboxed_renderer/init.js",
    "lib/sandboxed_renderer/api/exports/electron.js",
    "tsconfig.electron.json",
    "tsconfig.json",
  ]

  outputs = [
    "$target_gen_dir/js2c/preload_bundle.js",
  ]

  args = [
    "lib/sandboxed_renderer/init.js",
    "-r",
    "./lib/sandboxed_renderer/api/exports/electron.js:electron",
    "-t",
    "aliasify",
    "-p",
    "[",
    "tsify",
    "-p",
    "tsconfig.electron.json",
    "]",
    "-o",
    rebase_path(outputs[0]),
  ]
}

npm_action("atom_browserify_isolated") {
  script = "browserify"
  deps = [
    ":build_electron_definitions",
  ]

  inputs = [
    "lib/isolated_renderer/init.js",
    "tsconfig.electron.json",
    "tsconfig.json",
  ]

  outputs = [
    "$target_gen_dir/js2c/isolated_bundle.js",
  ]

  args = [
    "lib/isolated_renderer/init.js",
    "-t",
    "aliasify",
    "-p",
    "[",
    "tsify",
    "-p",
    "tsconfig.electron.json",
    "]",
    "-o",
    rebase_path(outputs[0]),
  ]
}

copy("atom_js2c_copy") {
  sources = [
    "lib/common/asar.js",
    "lib/common/asar_init.js",
  ]
  outputs = [
    "$target_gen_dir/js2c/{{source_file_part}}",
  ]
}

action("atom_js2c") {
  deps = [
    ":atom_browserify_isolated",
    ":atom_browserify_sandbox",
    ":atom_js2c_copy",
  ]

  browserify_sources = [
    "$target_gen_dir/js2c/isolated_bundle.js",
    "$target_gen_dir/js2c/preload_bundle.js",
  ]

  sources = browserify_sources + [
              "$target_gen_dir/js2c/asar.js",
              "$target_gen_dir/js2c/asar_init.js",
            ]

  inputs = sources
  outputs = [
    "$root_gen_dir/atom_natives.cc",
  ]

  script = "tools/js2c.py"
  args = [ rebase_path("//third_party/electron_node") ] +
         rebase_path(outputs, root_build_dir) +
         rebase_path(sources, root_build_dir)
}

target_gen_electron_js = "$target_gen_dir/js/electron"
target_gen_default_app_js = "$target_gen_dir/js/default_app"

typescript_build("lib_js") {
  deps = [
    ":build_electron_definitions",
  ]
  type_root = rebase_path("$target_gen_dir/tsc/electron/typings")

  sources = filenames.js_sources
  if (enable_desktop_capturer) {
    sources += [
      "lib/browser/desktop-capturer.js",
      "lib/renderer/api/desktop-capturer.js",
    ]
  }
  if (enable_view_api) {
    sources += [
      "lib/browser/api/views/box-layout.js",
      "lib/browser/api/views/button.js",
      "lib/browser/api/views/label-button.js",
      "lib/browser/api/views/layout-manager.js",
      "lib/browser/api/views/md-text-button.js",
      "lib/browser/api/views/resize-area.js",
      "lib/browser/api/views/text-field.js",
    ]
  }

  output_gen_dir = target_gen_electron_js
  output_dir_name = "lib"
  tsconfig = "tsconfig.electron.json"
}

asar("electron_asar") {
  deps = [
    ":lib_js",
  ]

  root = "$target_gen_electron_js/electron/lib"
  sources = get_target_outputs(":lib_js")
  outputs = [
    "$root_out_dir/resources/electron.asar",
  ]
}

typescript_build("default_app_js") {
  deps = [
    ":build_electron_definitions",
  ]
  type_root = rebase_path("$target_gen_dir/tsc/electron/typings")

  sources = filenames.default_app_ts_sources

  output_gen_dir = target_gen_default_app_js
  output_dir_name = "default_app"
  tsconfig = "tsconfig.default_app.json"
}

copy("default_app_static") {
  sources = filenames.default_app_static_sources
  outputs = [
    "$target_gen_default_app_js/{{source}}",
  ]
}

copy("default_app_octicon_deps") {
  sources = filenames.default_app_octicon_sources
  outputs = [
    "$target_gen_default_app_js/electron/default_app/octicon/{{source_file_part}}",
  ]
}

asar("default_app_asar") {
  deps = [
    ":default_app_js",
    ":default_app_octicon_deps",
    ":default_app_static",
  ]

  root = "$target_gen_default_app_js/electron/default_app"
  sources = get_target_outputs(":default_app_js") +
            get_target_outputs(":default_app_static") +
            get_target_outputs(":default_app_octicon_deps")
  outputs = [
    "$root_out_dir/resources/default_app.asar",
  ]
}

grit("resources") {
  source = "electron_resources.grd"

  outputs = [
    "grit/electron_resources.h",
    "electron_resources.pak",
  ]

  # Mojo manifest overlays are generated.
  source_is_generated = true
  grit_flags = [
    "-E",
    "target_gen_dir=" + rebase_path(target_gen_dir, root_build_dir),
  ]

  deps = [
    ":copy_shell_devtools_discovery_page",
    ":electron_content_manifest_overlays",
  ]

  output_dir = "$target_gen_dir"
}

copy("copy_shell_devtools_discovery_page") {
  sources = [
    "//content/shell/resources/shell_devtools_discovery_page.html",
  ]
  outputs = [
    "$target_gen_dir/shell_devtools_discovery_page.html",
  ]
}

if (is_linux) {
  generate_library_loader("libnotify_loader") {
    name = "LibNotifyLoader"
    output_h = "libnotify_loader.h"
    output_cc = "libnotify_loader.cc"
    header = "<libnotify/notify.h>"
    config = ":libnotify_config"

    functions = [
      "notify_is_initted",
      "notify_init",
      "notify_get_server_caps",
      "notify_get_server_info",
      "notify_notification_new",
      "notify_notification_add_action",
      "notify_notification_set_image_from_pixbuf",
      "notify_notification_set_timeout",
      "notify_notification_set_hint_string",
      "notify_notification_show",
      "notify_notification_close",
    ]
  }
}

static_library("electron_lib") {
  configs += [ "//v8:external_startup_data" ]
  configs += [ "//third_party/electron_node:node_internals" ]

  public_configs = [ ":branding" ]

  deps = [
    ":atom_js2c",
    "buildflags",
    "chromium_src:chrome",
    "native_mate",
    "//base",
    "//base:base_static",
    "//base:i18n",
    "//chrome/app/resources:platform_locale_settings",
    "//components/certificate_transparency",
    "//components/net_log",
    "//components/network_session_configurator/common",
    "//components/prefs",
    "//components/spellcheck/renderer",
    "//components/viz/host",
    "//components/viz/service",
    "//content/public/app:both",
    "//content/public/browser",
    "//content/public/child",
    "//content/public/common:service_names",
    "//gin",
    "//media/capture/mojom:video_capture",
    "//media/mojo/interfaces",
    "//net:extras",
    "//net:net_resources",
    "//net:net_with_v8",
    "//ppapi/host",
    "//ppapi/proxy",
    "//ppapi/shared_impl",
    "//services/audio/public/mojom:constants",
    "//services/device/public/mojom",
    "//services/proxy_resolver:lib",
    "//services/video_capture/public/mojom:constants",
    "//services/viz/privileged/interfaces/compositing",
    "//skia",
    "//third_party/blink/public:blink",
    "//third_party/boringssl",
    "//third_party/electron_node:node_lib",
    "//third_party/leveldatabase",
    "//third_party/libyuv",
    "//third_party/webrtc_overrides:init_webrtc",
    "//third_party/widevine/cdm:headers",
    "//ui/events:dom_keycode_converter",
    "//ui/gl",
    "//ui/views",
    "//v8",
  ]

  include_dirs = [
    "chromium_src",
    ".",
    "$target_gen_dir",

    # TODO(nornagon): replace usage of SchemeRegistry by an actually exported
    # API of blink, then remove this from the include_dirs.
    "//third_party/blink/renderer",
  ]

  defines = [ "V8_DEPRECATION_WARNINGS" ]
  libs = []

  if (is_linux) {
    defines += [ "GDK_DISABLE_DEPRECATION_WARNINGS" ]
  }

  extra_source_filters = []
  if (!is_linux) {
    extra_source_filters += [
      "*\bx/*",
      "*_x11.h",
      "*_x11.cc",
      "*_gtk.h",
      "*_gtk.cc",
      "*\blibrary_loaders/*",
    ]
  }
  if (!is_win) {
    extra_source_filters += [
      "*\bwin_*.h",
      "*\bwin_*.cc",
    ]
  }
  if (!is_posix) {
    extra_source_filters += [
      "*_posix.cc",
      "*_posix.h",
    ]
  }
  if (is_mac) {
    extra_source_filters += [
      "*_views.cc",
      "*_views.h",
      "*\bviews/*",
    ]
  }

  set_sources_assignment_filter(
      sources_assignment_filter + extra_source_filters)
  sources = filenames.lib_sources
  set_sources_assignment_filter(sources_assignment_filter)

  if (is_component_build) {
    defines += [ "NODE_SHARED_MODE" ]
  }

  if (enable_fake_location_provider) {
    sources += [
      "atom/browser/fake_location_provider.cc",
      "atom/browser/fake_location_provider.h",
    ]
  }

  if (is_mac) {
    deps += [
      "//third_party/crashpad/crashpad/client",
      "//ui/accelerated_widget_mac",
    ]
    sources += [
      "atom/browser/ui/views/autofill_popup_view.cc",
      "atom/browser/ui/views/autofill_popup_view.h",
    ]
    include_dirs += [
      # NOTE(nornagon): other chromium files use the full path to include
      # crashpad; this is just here for compatibility between GN and GYP, so that
      # the #includes can be agnostic about where crashpad is vendored.
      "//third_party/crashpad",
    ]
    if (is_mas_build) {
      deps -= [ "//third_party/crashpad/crashpad/client" ]
      sources += [ "atom/browser/api/atom_api_app_mas.mm" ]
      sources -= [
        "atom/browser/auto_updater_mac.mm",
        "atom/common/crash_reporter/crash_reporter_mac.h",
        "atom/common/crash_reporter/crash_reporter_mac.mm",
      ]
      defines += [ "MAS_BUILD" ]
    } else {
      libs += [
        "Squirrel.framework",
        "ReactiveCocoa.framework",
        "Mantle.framework",
      ]
      cflags_objcc = [
        "-F",
        rebase_path("external_binaries", root_build_dir),
      ]

      # ReactiveCocoa which is used by Squirrel requires using __weak.
      cflags_objcc += [ "-fobjc-weak" ]
    }
  }
  if (is_linux) {
    deps += [
      ":libnotify_loader",
      "//build/config/linux/gtk",
      "//chrome/browser/ui/libgtkui",
      "//dbus",
      "//device/bluetooth",
      "//ui/events/devices/x11",
      "//ui/events/platform/x11",
      "//ui/native_theme",
      "//ui/views/controls/webview",
      "//ui/wm",
    ]
    configs += [ ":gio_unix" ]
    defines += [
      # Disable warnings for g_settings_list_schemas.
      "GLIB_DISABLE_DEPRECATION_WARNINGS",
    ]

    sources += filenames.lib_sources_nss
  }
  if (is_win) {
    libs += [ "dwmapi.lib" ]
  }
  if (is_linux || is_win) {
    deps += [ "//third_party/breakpad:client" ]
    include_dirs += [ "//third_party/breakpad" ]
  }

  if (enable_pdf) {
    deps += [ "//pdf" ]
  }

  if (enable_run_as_node) {
    sources += [
      "atom/app/node_main.cc",
      "atom/app/node_main.h",
    ]
  }

  if (enable_osr) {
    sources += [
      "atom/browser/osr/osr_output_device.cc",
      "atom/browser/osr/osr_output_device.h",
      "atom/browser/osr/osr_render_widget_host_view.cc",
      "atom/browser/osr/osr_render_widget_host_view.h",
      "atom/browser/osr/osr_render_widget_host_view_mac.mm",
      "atom/browser/osr/osr_view_proxy.cc",
      "atom/browser/osr/osr_view_proxy.h",
      "atom/browser/osr/osr_web_contents_view.cc",
      "atom/browser/osr/osr_web_contents_view.h",
      "atom/browser/osr/osr_web_contents_view_mac.mm",
    ]
    deps += [
      "//components/viz/service",
      "//services/viz/public/interfaces",
      "//ui/compositor",
    ]
  }

  if (enable_desktop_capturer) {
    if (is_component_build && is_win) {
      # On windows the implementation relies on unexported
      # DxgiDuplicatorController class.
      deps += [ "//third_party/webrtc/modules/desktop_capture" ]
    }
    sources += [
      "atom/browser/api/atom_api_desktop_capturer.cc",
      "atom/browser/api/atom_api_desktop_capturer.h",
    ]
  }

  if (enable_view_api) {
    sources += [
      "atom/browser/api/views/atom_api_box_layout.cc",
      "atom/browser/api/views/atom_api_box_layout.h",
      "atom/browser/api/views/atom_api_button.cc",
      "atom/browser/api/views/atom_api_button.h",
      "atom/browser/api/views/atom_api_label_button.cc",
      "atom/browser/api/views/atom_api_label_button.h",
      "atom/browser/api/views/atom_api_layout_manager.cc",
      "atom/browser/api/views/atom_api_layout_manager.h",
      "atom/browser/api/views/atom_api_md_text_button.cc",
      "atom/browser/api/views/atom_api_md_text_button.h",
      "atom/browser/api/views/atom_api_resize_area.cc",
      "atom/browser/api/views/atom_api_resize_area.h",
      "atom/browser/api/views/atom_api_text_field.cc",
      "atom/browser/api/views/atom_api_text_field.h",
    ]
  }

  if (enable_basic_printing) {
    sources += [
      "atom/browser/printing/print_preview_message_handler.cc",
      "atom/browser/printing/print_preview_message_handler.h",
      "atom/renderer/printing/print_render_frame_helper_delegate.cc",
      "atom/renderer/printing/print_render_frame_helper_delegate.h",
    ]
  }

  if (enable_pepper_flash) {
    deps += [ "components/pepper_flash" ]
  }
}

electron_paks("packed_resources") {
  if (is_mac) {
    output_dir = "$root_gen_dir/electron_repack"
    copy_data_to_bundle = true
  } else {
    output_dir = root_out_dir
  }
}

if (is_mac) {
  electron_framework_name = "$electron_product_name Framework"
  electron_helper_name = "$electron_product_name Helper"
  electron_login_helper_name = "$electron_product_name Login Helper"
  electron_framework_version = "A"

  mac_xib_bundle_data("electron_xibs") {
    sources = [
      "atom/common/resources/mac/MainMenu.xib",
    ]
  }

  bundle_data("electron_framework_resources") {
    public_deps = [
      ":packed_resources",
    ]
    sources = []
    if (icu_use_data_file) {
      sources += [ "$root_out_dir/icudtl.dat" ]
      public_deps += [ "//third_party/icu:icudata" ]
    }
    if (v8_use_external_startup_data) {
      sources += [ "$root_out_dir/natives_blob.bin" ]
      public_deps += [ "//v8" ]
      if (use_v8_context_snapshot) {
        sources += [ "$root_out_dir/v8_context_snapshot.bin" ]
        public_deps += [ "//tools/v8_context_snapshot" ]
      } else {
        sources += [ "$root_out_dir/snapshot_blob.bin" ]
      }
    }
    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
  }

  if (!is_component_build) {
    bundle_data("electron_framework_libraries") {
      sources = []
      public_deps = []
      if (is_component_ffmpeg) {
        sources += [ "$root_out_dir/libffmpeg.dylib" ]
        public_deps += [ "//third_party/ffmpeg:ffmpeg" ]
      }
      outputs = [
        "{{bundle_contents_dir}}/Libraries/{{source_file_part}}",
      ]
    }
  } else {
    group("electron_framework_libraries") {
    }
  }

  bundle_data("electron_crashpad_helper") {
    sources = [
      "$root_out_dir/crashpad_handler",
    ]

    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]

    public_deps = [
      "//third_party/crashpad/crashpad/handler:crashpad_handler",
    ]
  }

  mac_framework_bundle("electron_framework") {
    output_name = electron_framework_name
    framework_version = electron_framework_version
    framework_contents = [
      "Resources",
      "Libraries",
    ]
    public_deps = [
      ":electron_lib",
    ]
    deps = [
      ":electron_framework_libraries",
      ":electron_framework_resources",
      ":electron_xibs",
    ]
    if (!is_mas_build) {
      deps += [ ":electron_crashpad_helper" ]
    }
    info_plist = "atom/common/resources/mac/Info.plist"

    electron_version = read_file("ELECTRON_VERSION", "trim string")
    extra_substitutions = [
      "ATOM_BUNDLE_ID=$electron_mac_bundle_id.framework",
      "ELECTRON_VERSION=$electron_version",
    ]

    include_dirs = [ "." ]
    sources = filenames.framework_sources

    libs = [
      "AVFoundation.framework",
      "Carbon.framework",
      "QuartzCore.framework",
      "Quartz.framework",
      "Security.framework",
      "SecurityInterface.framework",
      "ServiceManagement.framework",
      "StoreKit.framework",
    ]
    ldflags = [
      "-F",
      rebase_path("external_binaries", root_build_dir),
      "-Wl,-install_name,@rpath/$output_name.framework/$output_name",
      "-rpath",
      "@loader_path/Libraries",
    ]
    if (is_component_build) {
      ldflags += [
        "-rpath",
        "@executable_path/../../../../../..",
      ]
    }
  }

  mac_app_bundle("electron_helper_app") {
    output_name = electron_helper_name
    deps = [
      ":electron_framework+link",
    ]
    if (!is_mas_build) {
      deps += [ "//sandbox/mac:seatbelt" ]
      defines = [ "ENABLE_SEATBELT" ]
    }
    sources = filenames.app_sources
    include_dirs = [ "." ]
    info_plist = "atom/renderer/resources/mac/Info.plist"
    extra_substitutions = [ "ATOM_BUNDLE_ID=$electron_mac_bundle_id.helper" ]
    ldflags = [
      "-rpath",
      "@executable_path/../../..",
    ]
    if (is_component_build) {
      ldflags += [
        "-rpath",
        "@executable_path/../../../../../..",
      ]
    }
  }

  bundle_data("electron_app_framework_bundle_data") {
    sources = [
      "$root_out_dir/$electron_framework_name.framework",
      "$root_out_dir/$electron_helper_name.app",
    ]
    if (!is_mas_build) {
      sources += [
        "external_binaries/Mantle.framework",
        "external_binaries/ReactiveCocoa.framework",
        "external_binaries/Squirrel.framework",
      ]
    }
    outputs = [
      "{{bundle_contents_dir}}/Frameworks/{{source_file_part}}",
    ]
    public_deps = [
      ":electron_framework+link",
      ":electron_helper_app",
    ]
  }

  mac_app_bundle("electron_login_helper") {
    output_name = electron_login_helper_name
    sources = filenames.login_helper_sources
    include_dirs = [ "." ]
    libs = [ "AppKit.framework" ]
    info_plist = "atom/app/resources/mac/loginhelper-Info.plist"
    extra_substitutions =
        [ "ATOM_BUNDLE_ID=$electron_mac_bundle_id.loginhelper" ]
  }

  bundle_data("electron_login_helper_app") {
    public_deps = [
      ":electron_login_helper",
    ]
    sources = [
      "$root_out_dir/$electron_login_helper_name.app",
    ]
    outputs = [
      "{{bundle_contents_dir}}/Library/LoginItems/{{source_file_part}}",
    ]
  }

  action("electron_app_lproj_dirs") {
    outputs = []

    foreach(locale, locales_as_mac_outputs) {
      outputs += [ "$target_gen_dir/app_infoplist_strings/$locale.lproj" ]
    }
    script = "build/mac/make_locale_dirs.py"
    args = rebase_path(outputs)
  }

  foreach(locale, locales_as_mac_outputs) {
    bundle_data("electron_app_strings_${locale}_bundle_data") {
      sources = [
        "$target_gen_dir/app_infoplist_strings/$locale.lproj",
      ]
      outputs = [
        "{{bundle_resources_dir}}/$locale.lproj",
      ]
      public_deps = [
        ":electron_app_lproj_dirs",
      ]
    }
  }
  group("electron_app_strings_bundle_data") {
    public_deps = []
    foreach(locale, locales_as_mac_outputs) {
      public_deps += [ ":electron_app_strings_${locale}_bundle_data" ]
    }
  }

  bundle_data("electron_app_resources") {
    public_deps = [
      ":default_app_asar",
      ":electron_app_strings_bundle_data",
      ":electron_asar",
    ]
    sources = [
      "$root_out_dir/resources/default_app.asar",
      "$root_out_dir/resources/electron.asar",
      "atom/browser/resources/mac/electron.icns",
    ]
    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
  }

  mac_app_bundle("electron_app") {
    output_name = electron_product_name
    sources = filenames.app_sources
    include_dirs = [ "." ]
    deps = [
      ":electron_app_framework_bundle_data",
      ":electron_app_resources",
    ]
    if (is_mas_build) {
      deps += [ ":electron_login_helper_app" ]
    }
    info_plist = "atom/browser/resources/mac/Info.plist"
    extra_substitutions = [ "ATOM_BUNDLE_ID=$electron_mac_bundle_id" ]
    ldflags = [
      "-rpath",
      "@executable_path/../Frameworks",
    ]
  }
} else {
  windows_manifest("electron_app_manifest") {
    sources = [
      "atom/browser/resources/win/disable_window_filtering.manifest",
      "atom/browser/resources/win/dpi_aware.manifest",
      as_invoker_manifest,
      common_controls_manifest,
      default_compatibility_manifest,
    ]
  }

  executable("electron_app") {
    output_name = electron_project_name
    sources = filenames.app_sources
    include_dirs = [ "." ]
    deps = [
      ":default_app_asar",
      ":electron_app_manifest",
      ":electron_asar",
      ":electron_lib",
      ":packed_resources",
      "//content:sandbox_helper_win",
      "//ui/strings",
    ]

    data = []

    data += [ "$root_out_dir/resources.pak" ]
    data += [ "$root_out_dir/chrome_100_percent.pak" ]
    if (enable_hidpi) {
      data += [ "$root_out_dir/chrome_200_percent.pak" ]
    }
    foreach(locale, locales) {
      data += [ "$root_out_dir/locales/$locale.pak" ]
    }

    if (!is_mac) {
      data += [ "$root_out_dir/resources/default_app.asar" ]
      data += [ "$root_out_dir/resources/electron.asar" ]
    }

    public_deps = [
      "//tools/v8_context_snapshot:v8_context_snapshot",
    ]

    if (is_win) {
      sources += [
        # TODO: we should be generating our .rc files more like how chrome does
        "atom/browser/resources/win/atom.ico",
        "atom/browser/resources/win/atom.rc",
        "atom/browser/resources/win/resources.h",
      ]

      deps += [
        "//third_party/breakpad:breakpad_handler",
        "//third_party/breakpad:breakpad_sender",
        "//ui/native_theme:native_theme_browser",
        "//ui/shell_dialogs",
        "//ui/views/controls/webview",
        "//ui/wm",
        "//ui/wm/public",
      ]

      libs = [
        "comctl32.lib",
        "uiautomationcore.lib",
        "wtsapi32.lib",
      ]

      configs += [ "//build/config/win:windowed" ]

      ldflags = [
        # Windows 7 doesn't have these DLLs.
        # TODO: are there other DLLs we need to list here to be win7
        # compatible?
        "/DELAYLOAD:api-ms-win-core-winrt-l1-1-0.dll",
        "/DELAYLOAD:api-ms-win-core-winrt-string-l1-1-0.dll",
      ]

      # This is to support renaming of electron.exe. node-gyp has hard-coded
      # executable names which it will recognise as node. This module definition
      # file claims that the electron executable is in fact named "node.exe",
      # which is one of the executable names that node-gyp recognizes.
      # See https://github.com/nodejs/node-gyp/commit/52ceec3a6d15de3a8f385f43dbe5ecf5456ad07a
      ldflags += [ "/DEF:" + rebase_path("build/electron.def", root_build_dir) ]
      inputs = [
        "build/electron.def",
      ]
    }
    if (is_linux) {
      ldflags = [ "-pie" ]

      if (!is_component_build && is_component_ffmpeg) {
        configs += [ "//build/config/gcc:rpath_for_built_shared_libraries" ]
      }
    }
  }
}

template("dist_zip") {
  _runtime_deps_target = "${target_name}__deps"
  _runtime_deps_file =
      "$root_out_dir/gen.runtime/" + get_label_info(target_name, "dir") + "/" +
      get_label_info(target_name, "name") + ".runtime_deps"

  group(_runtime_deps_target) {
    forward_variables_from(invoker,
                           [
                             "deps",
                             "data_deps",
                             "data",
                           ])
    write_runtime_deps = _runtime_deps_file
  }

  action(target_name) {
    script = "//electron/build/zip.py"
    deps = [
      ":$_runtime_deps_target",
    ]
    forward_variables_from(invoker, [ "outputs" ])
    args = rebase_path(outputs + [ _runtime_deps_file ], root_build_dir) + [
             target_cpu,
             target_os,
           ]
  }
}

copy("electron_license") {
  sources = [
    "LICENSE",
  ]
  outputs = [
    "$root_build_dir/{{source_file_part}}",
  ]
}
copy("chromium_licenses") {
  deps = [
    "//components/resources:about_credits",
  ]
  sources = [
    "$root_gen_dir/components/resources/about_credits.html",
  ]
  outputs = [
    "$root_build_dir/LICENSES.chromium.html",
  ]
}

group("licenses") {
  data_deps = [
    ":electron_license",
    ":chromium_licenses",
  ]
}

copy("electron_version") {
  sources = [
    "ELECTRON_VERSION",
  ]
  outputs = [
    "$root_build_dir/version",
  ]
}

dist_zip("electron_dist_zip") {
  data_deps = [
    ":electron_app",
    ":licenses",
    ":electron_version",
  ]
  outputs = [
    "$root_build_dir/dist.zip",
  ]
}

dist_zip("electron_ffmpeg_zip") {
  data_deps = [
    "//third_party/ffmpeg",
  ]
  outputs = [
    "$root_build_dir/ffmpeg.zip",
  ]
}

dist_zip("electron_chromedriver_zip") {
  data_deps = [
    "//chrome/test/chromedriver",
    ":licenses",
  ]
  outputs = [
    "$root_build_dir/chromedriver.zip",
  ]
}

dist_zip("electron_mksnapshot_zip") {
  data_deps = [
    "//v8:mksnapshot($v8_snapshot_toolchain)",
    "//tools/v8_context_snapshot:v8_context_snapshot_generator",
    ":licenses",
  ]
  outputs = [
    "$root_build_dir/mksnapshot.zip",
  ]
}

group("electron") {
  public_deps = [
    ":electron_app",
  ]
}

group("electron_content_manifest_overlays") {
  deps = [
    ":electron_content_browser_manifest_overlay",
    ":electron_content_packaged_services_manifest_overlay",
  ]
}

service_manifest("electron_content_packaged_services_manifest_overlay") {
  source = "//electron/manifests/electron_content_packaged_services_manifest_overlay.json"
  packaged_services = [ "//services/proxy_resolver:proxy_resolver_manifest" ]

  if (enable_basic_printing) {
    packaged_services += [
      "//chrome/services/printing:manifest",
      "//components/services/pdf_compositor:pdf_compositor_manifest",
    ]
  }
}

service_manifest("electron_content_browser_manifest_overlay") {
  source = "//electron/manifests/electron_content_browser_manifest_overlay.json"
}