import("//build/config/locales.gni") import("//build/config/ui.gni") import("//build/config/win/manifest.gni") import("//components/os_crypt/sync/features.gni") import("//components/spellcheck/spellcheck_build_features.gni") import("//content/public/app/mac_helpers.gni") import("//extensions/buildflags/buildflags.gni") import("//pdf/features.gni") import("//ppapi/buildflags/buildflags.gni") import("//printing/buildflags/buildflags.gni") import("//testing/test.gni") import("//third_party/electron_node/electron_node.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/gni/snapshot_toolchain.gni") import("build/asar.gni") import("build/extract_symbols.gni") import("build/npm.gni") import("build/templated_file.gni") import("build/tsc.gni") import("build/webpack/webpack.gni") import("buildflags/buildflags.gni") import("electron_paks.gni") import("filenames.auto.gni") import("filenames.gni") import("filenames.hunspell.gni") import("filenames.libcxx.gni") import("filenames.libcxxabi.gni") import("js2c_toolchain.gni") if (is_mac) { import("//build/config/mac/rules.gni") import("//third_party/icu/config.gni") import("//ui/gl/features.gni") import("//v8/gni/v8.gni") import("build/rules.gni") assert( mac_deployment_target == "10.15", "Chromium has updated the mac_deployment_target, please update this assert, update the supported versions documentation (docs/tutorial/support.md) and flag this as a breaking change") } if (is_linux) { import("//build/config/linux/pkg_config.gni") import("//tools/generate_stubs/rules.gni") pkg_config("gio_unix") { packages = [ "gio-unix-2.0" ] } pkg_config("libnotify_config") { packages = [ "glib-2.0", "gdk-pixbuf-2.0", ] } generate_library_loader("libnotify_loader") { name = "LibNotifyLoader" output_h = "libnotify_loader.h" output_cc = "libnotify_loader.cc" header = "" 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_urgency", "notify_notification_set_hint", "notify_notification_show", "notify_notification_close", ] } # Generates headers which contain stubs for extracting function ptrs # from the gtk library. Function signatures for which stubs are # required should be declared in the sig files. generate_stubs("electron_gtk_stubs") { sigs = [ "shell/browser/ui/electron_gdk_pixbuf.sigs" ] extra_header = "shell/browser/ui/electron_gtk.fragment" output_name = "electron_gtk_stubs" public_deps = [ "//ui/gtk:gtk_config" ] logging_function = "LogNoop()" logging_include = "ui/gtk/log_noop.h" } } branding = read_file("shell/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 (override_electron_version != "") { electron_version = override_electron_version } else { # When building from source code tarball there is no git tag available and # builders must explicitly pass override_electron_version in gn args. # This read_file call will assert if there is no git information, without it # gn will generate a malformed build configuration and ninja will get into # infinite loop. read_file(".git/packed-refs", "string") # Set electron version from git tag. electron_version = exec_script("script/get-git-version.py", [], "trim string", [ ".git/packed-refs", ".git/HEAD", ]) } if (is_mas_build) { assert(is_mac, "It doesn't make sense to build a MAS build on a non-mac platform") } if (enable_pdf_viewer) { assert(enable_pdf, "PDF viewer support requires enable_pdf=true") assert(enable_electron_extensions, "PDF viewer support requires enable_electron_extensions=true") } if (enable_electron_extensions) { assert(enable_extensions, "Chrome extension support requires enable_extensions=true") } config("branding") { defines = [ "ELECTRON_PRODUCT_NAME=\"$electron_product_name\"", "ELECTRON_PROJECT_NAME=\"$electron_project_name\"", ] } config("electron_lib_config") { include_dirs = [ "." ] } # We generate 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 + [ "yarn.lock" ] outputs = [ "$target_gen_dir/tsc/typings/electron.d.ts" ] } webpack_build("electron_browser_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.browser_bundle_deps config_file = "//electron/build/webpack/webpack.config.browser.js" out_file = "$target_gen_dir/js2c/browser_init.js" } webpack_build("electron_renderer_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.renderer_bundle_deps config_file = "//electron/build/webpack/webpack.config.renderer.js" out_file = "$target_gen_dir/js2c/renderer_init.js" } webpack_build("electron_worker_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.worker_bundle_deps config_file = "//electron/build/webpack/webpack.config.worker.js" out_file = "$target_gen_dir/js2c/worker_init.js" } webpack_build("electron_sandboxed_renderer_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.sandbox_bundle_deps config_file = "//electron/build/webpack/webpack.config.sandboxed_renderer.js" out_file = "$target_gen_dir/js2c/sandbox_bundle.js" } webpack_build("electron_isolated_renderer_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.isolated_bundle_deps config_file = "//electron/build/webpack/webpack.config.isolated_renderer.js" out_file = "$target_gen_dir/js2c/isolated_bundle.js" } webpack_build("electron_node_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.node_bundle_deps config_file = "//electron/build/webpack/webpack.config.node.js" out_file = "$target_gen_dir/js2c/node_init.js" } webpack_build("electron_utility_bundle") { deps = [ ":build_electron_definitions" ] inputs = auto_filenames.utility_bundle_deps config_file = "//electron/build/webpack/webpack.config.utility.js" out_file = "$target_gen_dir/js2c/utility_init.js" } action("electron_js2c") { deps = [ ":electron_browser_bundle", ":electron_isolated_renderer_bundle", ":electron_node_bundle", ":electron_renderer_bundle", ":electron_sandboxed_renderer_bundle", ":electron_utility_bundle", ":electron_worker_bundle", "//third_party/electron_node:node_js2c($electron_js2c_toolchain)", ] sources = [ "$target_gen_dir/js2c/browser_init.js", "$target_gen_dir/js2c/isolated_bundle.js", "$target_gen_dir/js2c/node_init.js", "$target_gen_dir/js2c/renderer_init.js", "$target_gen_dir/js2c/sandbox_bundle.js", "$target_gen_dir/js2c/utility_init.js", "$target_gen_dir/js2c/worker_init.js", ] inputs = sources outputs = [ "$root_gen_dir/electron_natives.cc" ] script = "build/js2c.py" out_dir = get_label_info(":anything($electron_js2c_toolchain)", "root_out_dir") args = [ rebase_path("$out_dir/node_js2c"), rebase_path("$root_gen_dir"), ] + rebase_path(outputs, root_gen_dir) + rebase_path(sources, root_gen_dir) } action("generate_config_gypi") { outputs = [ "$root_gen_dir/config.gypi" ] script = "script/generate-config-gypi.py" inputs = [ "//third_party/electron_node/configure.py" ] args = rebase_path(outputs) + [ target_cpu ] } target_gen_default_app_js = "$target_gen_dir/js/default_app" typescript_build("default_app_js") { deps = [ ":build_electron_definitions" ] 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. grit_flags = [ "-E", "target_gen_dir=" + rebase_path(target_gen_dir, root_build_dir), ] deps = [ ":copy_shell_devtools_discovery_page" ] 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" ] } npm_action("electron_version_args") { script = "generate-version-json" outputs = [ "$target_gen_dir/electron_version.args" ] args = rebase_path(outputs) + [ "$electron_version" ] inputs = [ "script/generate-version-json.js" ] } templated_file("electron_version_header") { deps = [ ":electron_version_args" ] template = "build/templates/electron_version.tmpl" output = "$target_gen_dir/electron_version.h" args_files = get_target_outputs(":electron_version_args") } templated_file("electron_win_rc") { deps = [ ":electron_version_args" ] template = "build/templates/electron_rc.tmpl" output = "$target_gen_dir/win-resources/electron.rc" args_files = get_target_outputs(":electron_version_args") } copy("electron_win_resource_files") { sources = [ "shell/browser/resources/win/electron.ico", "shell/browser/resources/win/resource.h", ] outputs = [ "$target_gen_dir/win-resources/{{source_file_part}}" ] } templated_file("electron_version_file") { deps = [ ":electron_version_args" ] template = "build/templates/version_string.tmpl" output = "$root_build_dir/version" args_files = get_target_outputs(":electron_version_args") } group("electron_win32_resources") { public_deps = [ ":electron_win_rc", ":electron_win_resource_files", ] } action("electron_fuses") { script = "build/fuses/build.py" inputs = [ "build/fuses/fuses.json5" ] outputs = [ "$target_gen_dir/fuses.h", "$target_gen_dir/fuses.cc", ] args = rebase_path(outputs) } action("electron_generate_node_defines") { script = "build/generate_node_defines.py" inputs = [ "//third_party/electron_node/src/tracing/trace_event_common.h", "//third_party/electron_node/src/tracing/trace_event.h", "//third_party/electron_node/src/util.h", ] outputs = [ "$target_gen_dir/push_and_undef_node_defines.h", "$target_gen_dir/pop_node_defines.h", ] args = [ rebase_path(target_gen_dir) ] + rebase_path(inputs) } source_set("electron_lib") { configs += [ "//v8:external_startup_data", "//third_party/electron_node:node_internals", ] public_configs = [ ":branding", ":electron_lib_config", ] deps = [ ":electron_fuses", ":electron_generate_node_defines", ":electron_js2c", ":electron_version_header", ":resources", "buildflags", "chromium_src:chrome", "chromium_src:chrome_spellchecker", "shell/common/api:mojo", "shell/services/node/public/mojom", "//base:base_static", "//base/allocator:buildflags", "//chrome:strings", "//chrome/app:command_ids", "//chrome/app/resources:platform_locale_settings", "//components/autofill/core/common:features", "//components/certificate_transparency", "//components/compose:buildflags", "//components/embedder_support:browser_util", "//components/language/core/browser", "//components/net_log", "//components/network_hints/browser", "//components/network_hints/common:mojo_bindings", "//components/network_hints/renderer", "//components/network_session_configurator/common", "//components/omnibox/browser:buildflags", "//components/os_crypt/async/browser", "//components/os_crypt/async/browser:key_provider_interface", "//components/os_crypt/sync", "//components/pref_registry", "//components/prefs", "//components/security_state/content", "//components/upload_list", "//components/user_prefs", "//components/viz/host", "//components/viz/service", "//components/webrtc", "//content/public/browser", "//content/public/child", "//content/public/gpu", "//content/public/renderer", "//content/public/utility", "//device/bluetooth", "//device/bluetooth/public/cpp", "//gin", "//media/capture/mojom:video_capture", "//media/mojo/mojom", "//net:extras", "//net:net_resources", "//printing/buildflags", "//services/device/public/cpp/bluetooth:bluetooth", "//services/device/public/cpp/geolocation", "//services/device/public/cpp/hid", "//services/device/public/mojom", "//services/proxy_resolver:lib", "//services/video_capture/public/mojom:constants", "//services/viz/privileged/mojom/compositing", "//services/viz/public/mojom", "//skia", "//third_party/blink/public:blink", "//third_party/blink/public:blink_devtools_inspector_resources", "//third_party/blink/public/platform/media", "//third_party/boringssl", "//third_party/electron_node:node_lib", "//third_party/inspector_protocol:crdtp", "//third_party/leveldatabase", "//third_party/libyuv", "//third_party/webrtc_overrides:webrtc_component", "//third_party/widevine/cdm:headers", "//third_party/zlib/google:zip", "//ui/base:ozone_buildflags", "//ui/base/idle", "//ui/compositor", "//ui/events:dom_keycode_converter", "//ui/gl", "//ui/native_theme", "//ui/shell_dialogs", "//ui/views", "//ui/views/controls/webview", "//v8", "//v8:v8_libplatform", ] public_deps = [ "//base", "//base:i18n", "//content/public/app", ] include_dirs = [ ".", "$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" ] } if (!is_mas_build) { deps += [ "//components/crash/core/app", "//components/crash/core/browser", ] } configs += [ "//electron/build/config:mas_build" ] sources = filenames.lib_sources if (is_win) { sources += filenames.lib_sources_win } if (is_mac) { sources += filenames.lib_sources_mac } if (is_posix) { sources += filenames.lib_sources_posix } if (is_linux) { sources += filenames.lib_sources_linux } if (!is_mac) { sources += filenames.lib_sources_views } if (is_component_build) { defines += [ "NODE_SHARED_MODE" ] } if (enable_fake_location_provider) { sources += [ "shell/browser/fake_location_provider.cc", "shell/browser/fake_location_provider.h", ] } if (is_mac) { deps += [ "//components/remote_cocoa/app_shim", "//components/remote_cocoa/browser", "//content/browser:mac_helpers", "//ui/accelerated_widget_mac", ] if (!is_mas_build) { deps += [ "//third_party/crashpad/crashpad/client" ] } frameworks = [ "AuthenticationServices.framework", "AVFoundation.framework", "Carbon.framework", "LocalAuthentication.framework", "QuartzCore.framework", "Quartz.framework", "Security.framework", "SecurityInterface.framework", "ServiceManagement.framework", "StoreKit.framework", ] weak_frameworks = [ "QuickLookThumbnailing.framework" ] sources += [ "shell/browser/ui/views/autofill_popup_view.cc", "shell/browser/ui/views/autofill_popup_view.h", ] if (is_mas_build) { sources += [ "shell/browser/api/electron_api_app_mas.mm" ] sources -= [ "shell/browser/auto_updater_mac.mm" ] sources -= [ "shell/app/electron_crash_reporter_client.cc", "shell/app/electron_crash_reporter_client.h", "shell/common/crash_keys.cc", "shell/common/crash_keys.h", ] } else { frameworks += [ "Squirrel.framework", "ReactiveObjC.framework", "Mantle.framework", ] deps += [ "//third_party/squirrel.mac:reactiveobjc_framework+link", "//third_party/squirrel.mac:squirrel_framework+link", ] # ReactiveObjC which is used by Squirrel requires using __weak. cflags_objcc = [ "-fobjc-weak" ] } } if (is_linux) { libs = [ "xshmfence" ] deps += [ ":electron_gtk_stubs", ":libnotify_loader", "//build/config/linux/gtk", "//components/crash/content/browser", "//dbus", "//device/bluetooth", "//third_party/crashpad/crashpad/client", "//ui/base/ime/linux", "//ui/events/devices/x11", "//ui/events/platform/x11", "//ui/gtk:gtk_config", "//ui/linux:linux_ui", "//ui/linux:linux_ui_factory", "//ui/wm", ] if (ozone_platform_x11) { sources += filenames.lib_sources_linux_x11 public_deps += [ "//ui/base/x", "//ui/ozone/platform/x11", ] } configs += [ ":gio_unix" ] defines += [ # Disable warnings for g_settings_list_schemas. "GLIB_DISABLE_DEPRECATION_WARNINGS", ] sources += [ "shell/browser/certificate_manager_model.cc", "shell/browser/certificate_manager_model.h", "shell/browser/ui/gtk_util.cc", "shell/browser/ui/gtk_util.h", ] } if (is_win) { libs += [ "dwmapi.lib" ] sources += [ "shell/common/asar/archive_win.cc" ] deps += [ "//components/app_launch_prefetch", "//components/crash/core/app:crash_export_thunks", "//ui/native_theme:native_theme_browser", "//ui/wm", "//ui/wm/public", ] public_deps += [ "//sandbox/win:sandbox", "//third_party/crashpad/crashpad/handler", ] } if (enable_plugins) { deps += [ "chromium_src:plugins" ] sources += [ "shell/common/plugin_info.cc", "shell/common/plugin_info.h", "shell/renderer/electron_renderer_pepper_host_factory.cc", "shell/renderer/electron_renderer_pepper_host_factory.h", "shell/renderer/pepper_helper.cc", "shell/renderer/pepper_helper.h", ] } if (enable_ppapi) { deps += [ "//ppapi/host", "//ppapi/proxy", "//ppapi/shared_impl", ] } if (enable_printing) { sources += [ "shell/browser/printing/print_view_manager_electron.cc", "shell/browser/printing/print_view_manager_electron.h", "shell/browser/printing/printing_utils.cc", "shell/browser/printing/printing_utils.h", "shell/renderer/printing/print_render_frame_helper_delegate.cc", "shell/renderer/printing/print_render_frame_helper_delegate.h", ] deps += [ "//chrome/services/printing/public/mojom", "//components/printing/common:mojo_interfaces", ] if (is_mac) { deps += [ "//chrome/services/mac_notifications/public/mojom" ] } } if (enable_electron_extensions) { sources += filenames.lib_sources_extensions deps += [ "shell/browser/extensions/api:api_registration", "shell/common/extensions/api", "shell/common/extensions/api:extensions_features", "//chrome/browser/resources:component_extension_resources", "//components/guest_view/common:mojom", "//components/update_client:update_client", "//components/zoom", "//extensions/browser", "//extensions/browser/api:api_provider", "//extensions/browser/updater", "//extensions/common", "//extensions/common:core_api_provider", "//extensions/renderer", ] } if (enable_pdf) { # Printing depends on some //pdf code, so it needs to be built even if the # pdf viewer isn't enabled. deps += [ "//pdf", "//pdf:features", ] } if (enable_pdf_viewer) { deps += [ "//chrome/browser/resources/pdf:resources", "//components/pdf/browser", "//components/pdf/browser:interceptors", "//components/pdf/common:constants", "//components/pdf/common:util", "//components/pdf/renderer", "//pdf", "//pdf:content_restriction", ] sources += [ "shell/browser/electron_pdf_document_helper_client.cc", "shell/browser/electron_pdf_document_helper_client.h", "shell/browser/extensions/api/pdf_viewer_private/pdf_viewer_private_api.cc", "shell/browser/extensions/api/pdf_viewer_private/pdf_viewer_private_api.h", ] } sources += get_target_outputs(":electron_fuses") if (allow_runtime_configurable_key_storage) { defines += [ "ALLOW_RUNTIME_CONFIGURABLE_KEY_STORAGE" ] } } 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 = [ "shell/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) { public_deps += [ "//v8" ] if (use_v8_context_snapshot) { sources += [ "$root_out_dir/$v8_context_snapshot_filename" ] 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 && is_component_ffmpeg) { bundle_data("electron_framework_libraries") { sources = [] public_deps = [] 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") { } } if (use_egl) { # Add the ANGLE .dylibs in the Libraries directory of the Framework. bundle_data("electron_angle_binaries") { sources = [ "$root_out_dir/egl_intermediates/libEGL.dylib", "$root_out_dir/egl_intermediates/libGLESv2.dylib", ] outputs = [ "{{bundle_contents_dir}}/Libraries/{{source_file_part}}" ] public_deps = [ "//ui/gl:angle_library_copy" ] } # Add the SwiftShader .dylibs in the Libraries directory of the Framework. bundle_data("electron_swiftshader_binaries") { sources = [ "$root_out_dir/vk_intermediates/libvk_swiftshader.dylib", "$root_out_dir/vk_intermediates/vk_swiftshader_icd.json", ] outputs = [ "{{bundle_contents_dir}}/Libraries/{{source_file_part}}" ] public_deps = [ "//ui/gl:swiftshader_vk_library_copy" ] } } group("electron_angle_library") { if (use_egl) { deps = [ ":electron_angle_binaries" ] } } group("electron_swiftshader_library") { if (use_egl) { deps = [ ":electron_swiftshader_binaries" ] } } bundle_data("electron_crashpad_helper") { sources = [ "$root_out_dir/chrome_crashpad_handler" ] outputs = [ "{{bundle_contents_dir}}/Helpers/{{source_file_part}}" ] public_deps = [ "//components/crash/core/app:chrome_crashpad_handler" ] if (is_asan) { # crashpad_handler requires the ASan runtime at its @executable_path. sources += [ "$root_out_dir/libclang_rt.asan_osx_dynamic.dylib" ] public_deps += [ "//build/config/sanitizers:copy_sanitizer_runtime" ] } } mac_framework_bundle("electron_framework") { output_name = electron_framework_name framework_version = electron_framework_version framework_contents = [ "Resources", "Libraries", ] if (!is_mas_build) { framework_contents += [ "Helpers" ] } public_deps = [ ":electron_framework_libraries", ":electron_lib", ] deps = [ ":electron_angle_library", ":electron_framework_libraries", ":electron_framework_resources", ":electron_swiftshader_library", ":electron_xibs", ] if (!is_mas_build) { deps += [ ":electron_crashpad_helper" ] } info_plist = "shell/common/resources/mac/Info.plist" extra_substitutions = [ "ELECTRON_BUNDLE_ID=$electron_mac_bundle_id.framework", "ELECTRON_VERSION=$electron_version", ] include_dirs = [ "." ] sources = filenames.framework_sources frameworks = [ "IOSurface.framework" ] ldflags = [ "-Wl,-install_name,@rpath/$output_name.framework/$output_name", "-rpath", "@loader_path/Libraries", # Required for exporting all symbols of libuv. "-Wl,-force_load,obj/third_party/electron_node/deps/uv/libuv.a", ] if (is_component_build) { ldflags += [ "-rpath", "@executable_path/../../../../../..", ] } # For component ffmpeg under non-component build, it is linked from # @loader_path. However the ffmpeg.dylib is moved to a different place # when generating app bundle, and we should change to link from @rpath. if (is_component_ffmpeg && !is_component_build) { ldflags += [ "-Wcrl,installnametool,-change,@loader_path/libffmpeg.dylib,@rpath/libffmpeg.dylib" ] } } template("electron_helper_app") { mac_app_bundle(target_name) { assert(defined(invoker.helper_name_suffix)) output_name = electron_helper_name + invoker.helper_name_suffix deps = [ ":electron_framework+link" ] if (!is_mas_build) { deps += [ "//sandbox/mac:seatbelt" ] } defines = [ "HELPER_EXECUTABLE" ] configs += [ "//electron/build/config:mas_build" ] sources = [ "shell/app/electron_main_mac.cc", "shell/app/uv_stdio_fix.cc", "shell/app/uv_stdio_fix.h", "shell/common/electron_constants.cc", ] include_dirs = [ "." ] info_plist = "shell/renderer/resources/mac/Info.plist" extra_substitutions = [ "ELECTRON_BUNDLE_ID=$electron_mac_bundle_id.helper" ] ldflags = [ "-rpath", "@executable_path/../../..", ] if (is_component_build) { ldflags += [ "-rpath", "@executable_path/../../../../../..", ] } } } foreach(helper_params, content_mac_helpers) { _helper_target = helper_params[0] _helper_bundle_id = helper_params[1] _helper_suffix = helper_params[2] electron_helper_app("electron_helper_app_${_helper_target}") { helper_name_suffix = _helper_suffix } } template("stripped_framework") { action(target_name) { assert(defined(invoker.framework)) script = "//electron/build/strip_framework.py" forward_variables_from(invoker, [ "deps" ]) inputs = [ "$root_out_dir/" + invoker.framework ] outputs = [ "$target_out_dir/stripped_frameworks/" + invoker.framework ] args = rebase_path(inputs) + rebase_path(outputs) } } stripped_framework("stripped_mantle_framework") { framework = "Mantle.framework" deps = [ "//third_party/squirrel.mac:mantle_framework" ] } stripped_framework("stripped_reactiveobjc_framework") { framework = "ReactiveObjC.framework" deps = [ "//third_party/squirrel.mac:reactiveobjc_framework" ] } stripped_framework("stripped_squirrel_framework") { framework = "Squirrel.framework" deps = [ "//third_party/squirrel.mac:squirrel_framework" ] } bundle_data("electron_app_framework_bundle_data") { sources = [ "$root_out_dir/$electron_framework_name.framework" ] if (!is_mas_build) { sources += get_target_outputs(":stripped_mantle_framework") + get_target_outputs(":stripped_reactiveobjc_framework") + get_target_outputs(":stripped_squirrel_framework") } outputs = [ "{{bundle_contents_dir}}/Frameworks/{{source_file_part}}" ] public_deps = [ ":electron_framework+link", ":stripped_mantle_framework", ":stripped_reactiveobjc_framework", ":stripped_squirrel_framework", ] foreach(helper_params, content_mac_helpers) { sources += [ "$root_out_dir/${electron_helper_name}${helper_params[2]}.app" ] public_deps += [ ":electron_helper_app_${helper_params[0]}" ] } } mac_app_bundle("electron_login_helper") { output_name = electron_login_helper_name sources = filenames.login_helper_sources include_dirs = [ "." ] frameworks = [ "AppKit.framework" ] info_plist = "shell/app/resources/mac/loginhelper-Info.plist" extra_substitutions = [ "ELECTRON_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_apple_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_apple_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_apple_outputs) { public_deps += [ ":electron_app_strings_${locale}_bundle_data" ] } } bundle_data("electron_app_resources") { public_deps = [ ":default_app_asar", ":electron_app_strings_bundle_data", ] sources = [ "$root_out_dir/resources/default_app.asar", "shell/browser/resources/mac/electron.icns", ] outputs = [ "{{bundle_resources_dir}}/{{source_file_part}}" ] } asar_hashed_info_plist("electron_app_plist") { keys = [ "DEFAULT_APP_ASAR_HEADER_SHA" ] hash_targets = [ ":default_app_asar_header_hash" ] plist_file = "shell/browser/resources/mac/Info.plist" } mac_app_bundle("electron_app") { output_name = electron_product_name sources = [ "shell/app/electron_main_mac.cc", "shell/app/uv_stdio_fix.cc", "shell/app/uv_stdio_fix.h", ] include_dirs = [ "." ] deps = [ ":electron_app_framework_bundle_data", ":electron_app_plist", ":electron_app_resources", ":electron_fuses", "//electron/buildflags", ] if (is_mas_build) { deps += [ ":electron_login_helper_app" ] } info_plist_target = ":electron_app_plist" extra_substitutions = [ "ELECTRON_BUNDLE_ID=$electron_mac_bundle_id", "ELECTRON_VERSION=$electron_version", ] ldflags = [ "-rpath", "@executable_path/../Frameworks", ] configs += [ "//electron/build/config:mas_build" ] } if (enable_dsyms) { extract_symbols("electron_framework_syms") { binary = "$root_out_dir/$electron_framework_name.framework/Versions/$electron_framework_version/$electron_framework_name" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/$electron_framework_name.dSYM/Contents/Resources/DWARF/$electron_framework_name" deps = [ ":electron_framework" ] } foreach(helper_params, content_mac_helpers) { _helper_target = helper_params[0] _helper_bundle_id = helper_params[1] _helper_suffix = helper_params[2] extract_symbols("electron_helper_syms_${_helper_target}") { binary = "$root_out_dir/$electron_helper_name${_helper_suffix}.app/Contents/MacOS/$electron_helper_name${_helper_suffix}" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/$electron_helper_name${_helper_suffix}.dSYM/Contents/Resources/DWARF/$electron_helper_name${_helper_suffix}" deps = [ ":electron_helper_app_${_helper_target}" ] } } extract_symbols("electron_app_syms") { binary = "$root_out_dir/$electron_product_name.app/Contents/MacOS/$electron_product_name" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/$electron_product_name.dSYM/Contents/Resources/DWARF/$electron_product_name" deps = [ ":electron_app" ] } extract_symbols("egl_syms") { binary = "$root_out_dir/libEGL.dylib" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/libEGL.dylib.dSYM/Contents/Resources/DWARF/libEGL.dylib" deps = [ "//third_party/angle:libEGL" ] } extract_symbols("gles_syms") { binary = "$root_out_dir/libGLESv2.dylib" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/libGLESv2.dylib.dSYM/Contents/Resources/DWARF/libGLESv2.dylib" deps = [ "//third_party/angle:libGLESv2" ] } extract_symbols("crashpad_handler_syms") { binary = "$root_out_dir/chrome_crashpad_handler" symbol_dir = "$root_out_dir/breakpad_symbols" dsym_file = "$root_out_dir/chrome_crashpad_handler.dSYM/Contents/Resources/DWARF/chrome_crashpad_handler" deps = [ "//components/crash/core/app:chrome_crashpad_handler" ] } group("electron_symbols") { deps = [ ":egl_syms", ":electron_app_syms", ":electron_framework_syms", ":gles_syms", ] if (!is_mas_build) { deps += [ ":crashpad_handler_syms" ] } foreach(helper_params, content_mac_helpers) { _helper_target = helper_params[0] deps += [ ":electron_helper_syms_${_helper_target}" ] } } } else { group("electron_symbols") { } } } else { windows_manifest("electron_app_manifest") { sources = [ "shell/browser/resources/win/disable_window_filtering.manifest", "shell/browser/resources/win/dpi_aware.manifest", as_invoker_manifest, common_controls_manifest, default_compatibility_manifest, ] } executable("electron_app") { output_name = electron_project_name if (is_win) { sources = [ "shell/app/electron_main_win.cc" ] } else if (is_linux) { sources = [ "shell/app/electron_main_linux.cc", "shell/app/uv_stdio_fix.cc", "shell/app/uv_stdio_fix.h", ] } include_dirs = [ "." ] deps = [ ":default_app_asar", ":electron_app_manifest", ":electron_lib", ":electron_win32_resources", ":packed_resources", "//components/crash/core/app", "//content:sandbox_helper_win", "//electron/buildflags", "//ui/strings", ] data = [] data_deps = [] 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, platform_pak_locales) { data += [ "$root_out_dir/locales/$locale.pak" ] } if (!is_mac) { data += [ "$root_out_dir/resources/default_app.asar" ] } if (use_v8_context_snapshot) { public_deps = [ "//tools/v8_context_snapshot:v8_context_snapshot" ] } if (is_linux) { data_deps += [ "//components/crash/core/app:chrome_crashpad_handler" ] } if (is_win) { sources += [ "$target_gen_dir/win-resources/electron.rc", "shell/browser/resources/win/resource.h", ] deps += [ "//chrome/app:exit_code_watcher", "//components/crash/core/app:run_as_crashpad_handler", ] ldflags = [] libs = [ "comctl32.lib", "uiautomationcore.lib", "wtsapi32.lib", ] configs -= [ "//build/config/win:console" ] configs += [ "//build/config/win:windowed", "//build/config/win:delayloads", ] if (current_cpu == "x86") { # Set the initial stack size to 0.5MiB, instead of the 1.5MiB needed by # Chrome's main thread. This saves significant memory on threads (like # those in the Windows thread pool, and others) whose stack size we can # only control through this setting. Because Chrome's main thread needs # a minimum 1.5 MiB stack, the main thread (in 32-bit builds only) uses # fibers to switch to a 1.5 MiB stack before running any other code. ldflags += [ "/STACK:0x80000" ] } else { # Increase the initial stack size. The default is 1MB, this is 8MB. ldflags += [ "/STACK:0x800000" ] } # 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 = [ "shell/browser/resources/win/electron.ico", "build/electron.def", ] } if (is_linux) { ldflags = [ "-pie", # Required for exporting all symbols of libuv. "-Wl,--whole-archive", "obj/third_party/electron_node/deps/uv/libuv.a", "-Wl,--no-whole-archive", ] if (!is_component_build && is_component_ffmpeg) { configs += [ "//build/config/gcc:rpath_for_built_shared_libraries" ] } if (is_linux) { deps += [ "//sandbox/linux:chrome_sandbox" ] } } } if (is_official_build) { if (is_linux) { _target_executable_suffix = "" _target_shared_library_suffix = ".so" } else if (is_win) { _target_executable_suffix = ".exe" _target_shared_library_suffix = ".dll" } extract_symbols("electron_app_symbols") { binary = "$root_out_dir/$electron_project_name$_target_executable_suffix" symbol_dir = "$root_out_dir/breakpad_symbols" deps = [ ":electron_app" ] } extract_symbols("egl_symbols") { binary = "$root_out_dir/libEGL$_target_shared_library_suffix" symbol_dir = "$root_out_dir/breakpad_symbols" deps = [ "//third_party/angle:libEGL" ] } extract_symbols("gles_symbols") { binary = "$root_out_dir/libGLESv2$_target_shared_library_suffix" symbol_dir = "$root_out_dir/breakpad_symbols" deps = [ "//third_party/angle:libGLESv2" ] } group("electron_symbols") { deps = [ ":egl_symbols", ":electron_app_symbols", ":gles_symbols", ] } } } 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", "testonly", ]) write_runtime_deps = _runtime_deps_file } action(target_name) { script = "//electron/build/zip.py" deps = [ ":$_runtime_deps_target" ] forward_variables_from(invoker, [ "outputs", "testonly", ]) flatten = false flatten_relative_to = false if (defined(invoker.flatten)) { flatten = invoker.flatten if (defined(invoker.flatten_relative_to)) { flatten_relative_to = invoker.flatten_relative_to } } args = rebase_path(outputs + [ _runtime_deps_file ], root_build_dir) + [ target_cpu, target_os, "$flatten", "$flatten_relative_to", ] } } 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 = [ ":chromium_licenses", ":electron_license", ] } dist_zip("electron_dist_zip") { data_deps = [ ":electron_app", ":electron_version_file", ":licenses", ] if (is_linux) { data_deps += [ "//sandbox/linux:chrome_sandbox" ] } deps = data_deps outputs = [ "$root_build_dir/dist.zip" ] } dist_zip("electron_ffmpeg_zip") { data_deps = [ "//third_party/ffmpeg" ] deps = data_deps outputs = [ "$root_build_dir/ffmpeg.zip" ] } electron_chromedriver_deps = [ ":licenses", "//chrome/test/chromedriver:chromedriver_server", "//electron/buildflags", ] group("electron_chromedriver") { testonly = true public_deps = electron_chromedriver_deps } dist_zip("electron_chromedriver_zip") { testonly = true data_deps = electron_chromedriver_deps deps = data_deps outputs = [ "$root_build_dir/chromedriver.zip" ] } mksnapshot_deps = [ ":licenses", "//v8:mksnapshot($v8_snapshot_toolchain)", ] if (use_v8_context_snapshot) { mksnapshot_deps += [ "//tools/v8_context_snapshot:v8_context_snapshot_generator($v8_snapshot_toolchain)" ] } group("electron_mksnapshot") { public_deps = mksnapshot_deps } dist_zip("electron_mksnapshot_zip") { data_deps = mksnapshot_deps deps = data_deps outputs = [ "$root_build_dir/mksnapshot.zip" ] } copy("hunspell_dictionaries") { sources = hunspell_dictionaries + hunspell_licenses outputs = [ "$target_gen_dir/electron_hunspell/{{source_file_part}}" ] } dist_zip("hunspell_dictionaries_zip") { data_deps = [ ":hunspell_dictionaries" ] deps = data_deps flatten = true outputs = [ "$root_build_dir/hunspell_dictionaries.zip" ] } copy("libcxx_headers") { sources = libcxx_headers + libcxx_licenses + [ "//buildtools/third_party/libc++/__assertion_handler", "//buildtools/third_party/libc++/__config_site", ] outputs = [ "$target_gen_dir/electron_libcxx_include/{{source_root_relative_dir}}/{{source_file_part}}" ] } dist_zip("libcxx_headers_zip") { data_deps = [ ":libcxx_headers" ] deps = data_deps flatten = true flatten_relative_to = rebase_path( "$target_gen_dir/electron_libcxx_include/third_party/libc++/src", "$root_out_dir") outputs = [ "$root_build_dir/libcxx_headers.zip" ] } copy("libcxxabi_headers") { sources = libcxxabi_headers + libcxxabi_licenses outputs = [ "$target_gen_dir/electron_libcxxabi_include/{{source_root_relative_dir}}/{{source_file_part}}" ] } dist_zip("libcxxabi_headers_zip") { data_deps = [ ":libcxxabi_headers" ] deps = data_deps flatten = true flatten_relative_to = rebase_path( "$target_gen_dir/electron_libcxxabi_include/third_party/libc++abi/src", "$root_out_dir") outputs = [ "$root_build_dir/libcxxabi_headers.zip" ] } action("libcxx_objects_zip") { deps = [ "//buildtools/third_party/libc++" ] script = "build/zip_libcxx.py" outputs = [ "$root_build_dir/libcxx_objects.zip" ] args = rebase_path(outputs) } group("electron") { public_deps = [ ":electron_app" ] } ##### node_headers node_dir = "../third_party/electron_node" node_files = read_file("$node_dir/filenames.json", "json") node_headers_dir = "$root_gen_dir/node_headers" header_group_index = 0 header_groups = [] foreach(header_group, node_files.headers) { copy("node_headers_${header_group_index}") { sources = rebase_path(header_group.files, ".", node_dir) outputs = [ "$node_headers_dir/${header_group.dest_dir}/{{source_file_part}}" ] } header_groups += [ ":node_headers_${header_group_index}" ] header_group_index += 1 } copy("zlib_headers") { sources = [ "$node_dir/deps/zlib/zconf.h", "$node_dir/deps/zlib/zlib.h", ] outputs = [ "$node_headers_dir/include/node/{{source_file_part}}" ] } copy("node_gypi_headers") { deps = [ ":generate_config_gypi" ] sources = [ "$node_dir/common.gypi", "$root_gen_dir/config.gypi", ] outputs = [ "$node_headers_dir/include/node/{{source_file_part}}" ] } action("node_version_header") { inputs = [ "$node_dir/src/node_version.h" ] outputs = [ "$node_headers_dir/include/node/node_version.h" ] script = "script/generate_node_version_header.py" args = rebase_path(inputs) + rebase_path(outputs) if (node_module_version != "") { args += [ "$node_module_version" ] } } action("tar_node_headers") { deps = [ ":copy_node_headers" ] outputs = [ "$root_gen_dir/node_headers.tar.gz" ] script = "script/tar.py" args = [ rebase_path("$root_gen_dir/node_headers"), rebase_path(outputs[0]), ] } group("copy_node_headers") { public_deps = header_groups + [ ":node_gypi_headers", ":node_version_header", ":zlib_headers", ] } group("node_headers") { public_deps = [ ":tar_node_headers" ] }