# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/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/sanitizers/sanitizers.gni")
import("//build/config/ui.gni")
import("//build/config/win/console_app.gni")
import("//build/config/win/manifest.gni")
import("//chrome/chrome_repack_locales.gni")
import("//chrome/common/features.gni")
import("//chrome/version.gni")
import("//ui/base/ui_features.gni")

if (is_android) {
  import("//build/config/android/rules.gni")
} else if (is_mac) {
  import("//build/compiled_action.gni")
  import("//build/config/mac/rules.gni")
  import("//build/config/mac/symbols.gni")
  import("//build/mac/tweak_info_plist.gni")
  import("//build/util/branding.gni")
  import("//build/util/version.gni")
  import("//build_overrides/v8.gni")
  import("//media/cdm/ppapi/cdm_paths.gni")
}

if (is_win) {
  action("reorder_imports") {
    script = "//build/win/reorder-imports.py"

    # See comment in chrome_dll.gypi in the hardlink_to_output
    # target for why this cannot be 'initial' like the DLL.
    inputs = [
      "$root_out_dir/initialexe/chrome.exe",
    ]
    outputs = [
      "$root_out_dir/chrome.exe",
      "$root_out_dir/chrome.exe.pdb",
    ]
    args = [
      "-i",
      rebase_path("$root_out_dir/initialexe", root_build_dir),
      "-o",
      rebase_path("$root_out_dir", root_build_dir),
      "-a",
      current_cpu,
    ]
    deps = [
      ":chrome_initial",
    ]
  }
}

if (!is_android && !is_mac) {
  group("chrome") {
    public_deps = [
      ":chrome_initial",
    ]
    data_deps = [
      ":chrome_initial",
    ]
    if (is_win) {
      public_deps += [ ":reorder_imports" ]
    }
    if (use_aura && (is_win || is_linux)) {
      data_deps += [ "//chrome/app:mojo_manifests" ]
    }
  }

  executable("chrome_initial") {
    if (is_win) {
      output_name = "initialexe/chrome"
    } else {
      output_name = "chrome"
    }

    # Because the sources list varies so significantly per-platform, generally
    # each platform lists its own files rather than relying on filtering or
    # removing unused files.
    sources = [
      "app/chrome_exe_resource.h",
    ]
    defines = []
    public_deps = []
    deps = [
      "//build/config/sanitizers:deps",
    ]

    data = [
      "$root_out_dir/resources.pak",
    ]
    if (is_linux || is_win) {
      data += [
        "$root_out_dir/chrome_100_percent.pak",
        "$root_out_dir/locales/en-US.pak",
        "$root_out_dir/locales/fr.pak",
      ]
    }

    data_deps = []

    if (is_win) {
      sources += [
        "app/chrome_crash_reporter_client_win.cc",
        "app/chrome_crash_reporter_client_win.h",
        "app/chrome_exe.rc",
        "app/chrome_exe_load_config_win.cc",
        "app/chrome_exe_main_win.cc",
        "app/chrome_watcher_client_win.cc",
        "app/chrome_watcher_client_win.h",
        "app/chrome_watcher_command_line_win.cc",
        "app/chrome_watcher_command_line_win.h",
        "app/kasko_client.cc",
        "app/kasko_client.h",
        "app/main_dll_loader_win.cc",
        "app/main_dll_loader_win.h",
        "common/crash_keys.cc",
        "common/crash_keys.h",
      ]

      deps += [
        ":chrome_dll",
        ":chrome_exe_version",
        ":file_pre_reader",
        ":visual_elements_resources",
        "//base",
        "//breakpad:breakpad_handler",
        "//breakpad:breakpad_sender",
        "//chrome/app/version_assembly:chrome_exe_manifest",
        "//chrome/browser:chrome_process_finder",
        "//chrome/chrome_watcher",
        "//chrome/chrome_watcher:client",
        "//chrome/common:constants",
        "//chrome/common:metrics_constants_util_win",
        "//chrome/install_static:install_static_util",
        "//chrome/installer/util:with_no_strings",
        "//chrome_elf",
        "//components/browser_watcher:browser_watcher_client",
        "//components/crash/content/app",
        "//components/crash/core/common",
        "//components/flags_ui:switches",
        "//components/startup_metric_utils/common",
        "//content:sandbox_helper_win",
        "//content/public/common:static_switches",
        "//crypto",
        "//sandbox",
        "//ui/gfx",
      ]
      data_deps = [
        "//chrome/app/version_assembly:version_assembly_manifest",
      ]

      if (win_console_app) {
        defines += [ "WIN_CONSOLE_APP" ]
      } else {
        # Set /SUBSYSTEM:WINDOWS for chrome.exe itself, unless a console build
        # has been requested.
        configs -= [ "//build/config/win:console" ]
        configs += [ "//build/config/win:windowed" ]
      }

      ldflags = [
        "/DELAYLOAD:dbghelp.dll",
        "/DELAYLOAD:dwmapi.dll",
        "/DELAYLOAD:uxtheme.dll",
        "/DELAYLOAD:ole32.dll",
        "/DELAYLOAD:oleaut32.dll",
      ]
    } else if (use_aura) {
      # Non-Windows aura entrypoint.
      sources += [ "app/chrome_exe_main_aura.cc" ]
    }

    if (is_linux) {
      sources += [
        "app/chrome_dll_resource.h",
        "app/chrome_main.cc",
        "app/chrome_main_delegate.cc",
        "app/chrome_main_delegate.h",
      ]

      deps += [
        # On Linux, link the dependencies (libraries) that make up actual
        # Chromium functionality directly into the executable.
        ":browser_dependencies",
        ":child_dependencies",
        ":manpage",

        # Needed to use the master_preferences functions
        "//chrome/installer/util:with_no_strings",
        "//content/public/app:both",
      ]
      if (enable_plugins && enable_pdf) {
        deps += [ "//pdf" ]
      }

      public_deps = [
        ":xdg_mime",  # Needs to be public for installer to consume files.
        "//chrome/common:features",
      ]

      # GYP has this in a 'profiling==0 and linux_disable_pie==0' condition.
      # but GN doesn't have either of these flags.
      ldflags = [ "-pie" ]

      if (use_pango || use_cairo) {
        # Needed for chrome_main.cc initialization of libraries.
        configs += [ "//build/config/linux/pangocairo" ]
      }

      if (use_x11) {
        configs += [
          "//build/config/linux:x11",
          "//build/config/linux:xext",
        ]
      }

      if (enable_package_mash_services) {
        deps += [ "//chrome/app/mash" ]
        data_deps += [ "//chrome/app:mojo_manifests" ]
      }
    }

    # These files are used by the installer so we need a public dep.
    public_deps += [
      ":packed_extra_resources",
      ":packed_resources",
    ]
    deps += [
      "//components/startup_metric_utils/browser:lib",

      # Precompiled plugins that need to get copied to the output directory.
      # On Mac, internal plugins go inside the framework, so these
      # dependencies are on chrome.dll.
      "//third_party/adobe/flash:flapper_binaries",
    ]

    data_deps += [ "//third_party/widevine/cdm:widevinecdmadapter" ]

    if (is_multi_dll_chrome) {
      defines += [ "CHROME_MULTIPLE_DLL" ]
      data_deps += [ ":chrome_child" ]
    }
  }
}  # !is_android && !is_mac

if (is_win) {
  # This target is a forwarding target to compile the necessary DLLs used
  # by Chrome.
  group("chrome_dll") {
    # TODO(GYP) support incremental_chrome_dll on Windows for faster links in
    # developer component builds. When that's supported, this target will need
    # to become more complicated.
    data_deps = [
      ":main_dll",
    ]
    if (is_multi_dll_chrome) {
      data_deps += [ ":chrome_child" ]
    }
  }

  shared_library("main_dll") {
    configs += [ "//build/config/compiler:wexit_time_destructors" ]
    defines = []
    ldflags = []

    sources = [
      "//base/win/dllmain.cc",
      "app/chrome_command_ids.h",
      "app/chrome_dll.rc",
      "app/chrome_dll_resource.h",
      "app/chrome_main.cc",
      "app/chrome_main_delegate.cc",
      "app/chrome_main_delegate.h",
      "app/chrome_main_mac.h",
      "app/chrome_main_mac.mm",
    ]

    deps = [
      ":browser_dependencies",
      "//build/config/sanitizers:deps",
      "//chrome/common:features",
      "//third_party/cld_2",
    ]
    if (is_win) {
      output_name = "chrome"

      deps += [
        ":chrome_dll_manifest",
        ":chrome_dll_version",
        "//base/trace_event/etw_manifest:chrome_events_win",
        "//chrome/app/theme:chrome_unscaled_resources",
        "//chrome/install_static:install_static_util",
        "//chrome_elf",
        "//components/crash/content/app",
        "//components/policy",
        "//content/app/resources",
        "//crypto",
        "//net:net_resources",
        "//third_party/wtl",
        "//ui/views",
      ]

      ldflags += [
        "/DELAYLOAD:comdlg32.dll",
        "/DELAYLOAD:crypt32.dll",
        "/DELAYLOAD:cryptui.dll",
        "/DELAYLOAD:dhcpcsvc.dll",
        "/DELAYLOAD:dwmapi.dll",
        "/DELAYLOAD:imagehlp.dll",
        "/DELAYLOAD:imm32.dll",
        "/DELAYLOAD:iphlpapi.dll",
        "/DELAYLOAD:setupapi.dll",
        "/DELAYLOAD:urlmon.dll",
        "/DELAYLOAD:winhttp.dll",
        "/DELAYLOAD:wininet.dll",
        "/DELAYLOAD:winspool.drv",
        "/DELAYLOAD:ws2_32.dll",
        "/DELAYLOAD:wsock32.dll",
      ]

      # This is a large module that can't do incremental linking in some cases.
      configs -= [ "//build/config/win:default_incremental_linking" ]
      configs +=
          [ "//build/config/win:default_large_module_incremental_linking" ]
    }

    if (use_aura) {
      deps += [ "//ui/compositor" ]
    }

    if (is_multi_dll_chrome) {
      defines += [ "CHROME_MULTIPLE_DLL_BROWSER" ]
      deps += [ "//content/public/app:browser" ]
    } else {
      deps += [
        ":child_dependencies",
        "//content/public/app:both",
      ]
    }

    if (enable_plugins && enable_pdf && !is_multi_dll_chrome) {
      deps += [ "//pdf" ]
    }

    if (enable_package_mash_services) {
      deps += [ "//chrome/app/mash" ]
    }
  }

  if (is_multi_dll_chrome) {
    # This manifest matches what GYP produces. It may not even be necessary.
    windows_manifest("chrome_child_manifest") {
      sources = [
        as_invoker_manifest,
      ]
      type = "dll"
    }

    shared_library("chrome_child") {
      sources = [
        "app/chrome_main.cc",
        "app/chrome_main_delegate.cc",
        "app/chrome_main_delegate.h",
      ]

      configs += [ "//build/config/compiler:wexit_time_destructors" ]
      defines = [ "CHROME_MULTIPLE_DLL_CHILD" ]

      deps = [
        ":child_dependencies",
        ":chrome_child_manifest",
        ":chrome_dll_version",
        "//build/config/sanitizers:deps",
        "//chrome/common:features",
        "//components/browser_watcher:browser_watcher_client",
        "//components/crash/content/app",
        "//content/public/app:child",
      ]

      if (is_win) {
        deps += [ "//chrome/install_static:install_static_util" ]

        ldflags = [
          "/DELAYLOAD:d3d11.dll",
          "/DELAYLOAD:d3d9.dll",
          "/DELAYLOAD:dwmapi.dll",
          "/DELAYLOAD:dxva2.dll",
          "/DELAYLOAD:esent.dll",
          "/DELAYLOAD:wininet.dll",
        ]

        if (symbol_level == 2) {
          # Incremental linking doesn't work on this target in debug mode with
          # full symbols, but does work in other cases, including minimal
          # symbols.
          configs -= [ "//build/config/win:default_incremental_linking" ]
          configs += [ "//build/config/win:no_incremental_linking" ]
        }
        if (chrome_pgo_phase == 1) {
          ldflags += [
            "/LTCG:PGINSTRUMENT",
            "/PogoSafeMode",
          ]
        } else if (chrome_pgo_phase == 2) {
          ldflags += [ "/LTCG:PGOPTIMIZE" ]
        }
      }

      deps += [ "//chrome/browser/policy:path_parser" ]

      if (enable_plugins && enable_pdf) {
        deps += [ "//pdf" ]
      }
    }
  }
} else if (is_mac) {
  chrome_helper_name = chrome_product_full_name + " Helper"
  chrome_framework_name = chrome_product_full_name + " Framework"

  group("chrome") {
    deps = [
      ":chrome_app",
    ]

    data_deps = [
      ":chrome_app",
    ]

    if (debug_devtools) {
      deps += [ ":devtools_debug_resources" ]
    }

    if (is_chrome_branded && is_official_build) {
      deps += [
        ":chrome_dsym_archive",
        ":chrome_dump_syms",
      ]
    }
  }

  tweak_info_plist("chrome_app_plist") {
    info_plist = "app/app-Info.plist"
    _keystone_arg = "0"
    if (enable_mac_keystone) {
      _keystone_arg = "1"
    }
    args = [
      "--breakpad=0",
      "--keystone=$_keystone_arg",
      "--scm=1",
      "--bundle_id=$chrome_mac_bundle_id",
    ]
  }

  mac_app_bundle("chrome_app") {
    output_name = chrome_product_full_name

    info_plist_target = ":chrome_app_plist"
    extra_substitutions = [
      "CHROMIUM_BUNDLE_ID=$chrome_mac_bundle_id",
      "CHROMIUM_SHORT_NAME=$chrome_product_short_name",
      "CHROMIUM_CREATOR=$chrome_mac_creator_code",
    ]

    sources = [
      "app/chrome_exe_main_mac.c",
    ]

    deps = [
      ":chrome_app_strings_bundle_data",
      ":chrome_resources",
      ":chrome_versioned_bundle_data",
      "//chrome/common:version_header",
    ]

    # Remove the default strip configuration (which strips all symbols) so that
    # a saves file can be specified.
    if (enable_stripping) {
      remove_configs = [ "//build/config/mac:strip_all" ]

      ldflags =
          [ "-Wcrl,strip,-s," + rebase_path("app/app.saves", root_build_dir) ]
    }
  }

  compiled_action("chrome_app_strings") {
    tool = "//chrome/tools/mac_helpers:infoplist_strings_tool"

    inputs = [
      chrome_version_file,
    ]

    outputs = []

    foreach(locale, locales) {
      if (is_chrome_branded) {
        _strings_file = "google_chrome_strings"
      } else {
        _strings_file = "chromium_strings"
      }

      inputs += [ "$root_gen_dir/chrome/${_strings_file}_${locale}.pak" ]
    }

    foreach(locale, locales_as_mac_outputs) {
      outputs += [ "$target_gen_dir/app_infoplist_strings/$locale.lproj/InfoPlist.strings" ]
    }

    args =
        [
          "-b",
          "${branding_path_component}_strings",
          "-v",
          rebase_path(chrome_version_file, root_build_dir),
          "-g",
          rebase_path("$root_gen_dir/chrome", root_build_dir),
          "-o",
          rebase_path("$target_gen_dir/app_infoplist_strings", root_build_dir),
          "-t",
          "main",
        ] + locales

    if (is_chrome_branded) {
      deps = [
        "//chrome/app:google_chrome_strings",
      ]
    } else {
      deps = [
        "//chrome/app:chromium_strings",
      ]
    }
  }

  foreach(locale, locales_as_mac_outputs) {
    bundle_data("chrome_app_strings_${locale}_bundle_data") {
      sources = [
        "$target_gen_dir/app_infoplist_strings/$locale.lproj/InfoPlist.strings",
      ]
      outputs = [
        "{{bundle_resources_dir}}/$locale.lproj/{{source_file_part}}",
      ]
      public_deps = [
        ":chrome_app_strings",
      ]
    }
  }
  group("chrome_app_strings_bundle_data") {
    public_deps = []
    foreach(locale, locales_as_mac_outputs) {
      public_deps += [ ":chrome_app_strings_${locale}_bundle_data" ]
    }
  }

  bundle_data("chrome_resources") {
    sources = [
      "$root_out_dir/$chrome_mac_bundle_id.manifest",
      "app/theme/$branding_path_component/mac/app.icns",
      "app/theme/$branding_path_component/mac/document.icns",
      "browser/ui/cocoa/applescript/scripting.sdef",
    ]
    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
    public_deps = [
      ":chrome_app_strings",
      "//components/policy:chrome_manifest_bundle",
    ]
  }

  bundle_data("chrome_versioned_bundle_data") {
    sources = [
      "$root_out_dir/$chrome_framework_name.framework",
      "$root_out_dir/$chrome_helper_name.app",
    ]
    outputs = [
      "{{bundle_root_dir}}/Versions/$chrome_version_full/{{source_file_part}}",
    ]
    public_deps = [
      ":chrome_helper_app",

      # keystone_registration_framework copies the framework into the framework
      # bundle via a script that performs additional actions, rather than
      # relying on a bundle_data to copy it.
      ":keystone_registration_framework",

      # verify_chrome_framework_order depends on :chrome_framework and, for
      # non-component builds, will ensure the export symbol table is correct.
      ":verify_chrome_framework_order",
    ]
  }

  tweak_info_plist("chrome_helper_plist") {
    info_plist = "app/helper-Info.plist"
    args = [
      "--breakpad=0",
      "--keystone=0",
      "--scm=0",
    ]
  }

  mac_app_bundle("chrome_helper_app") {
    output_name = chrome_helper_name

    info_plist_target = ":chrome_helper_plist"
    extra_substitutions = [
      "CHROMIUM_BUNDLE_ID=$chrome_mac_bundle_id",
      "CHROMIUM_SHORT_NAME=$chrome_product_short_name",
    ]

    sources = [
      "app/chrome_exe_main_mac.c",
    ]

    defines = [ "HELPER_EXECUTABLE" ]

    deps = [
      "//chrome/common:version_header",
    ]

    ldflags = [
      # The helper is in Chromium.app/Contents/Versions/X/Chromium Helper.app/Conents/MacOS/
      # so set rpath up to the base.
      "-rpath",
      "@loader_path/../../../../../../..",
    ]

    # Remove the default strip configuration (which strips all symbols) so that
    # a saves file can be specified.
    if (enable_stripping) {
      remove_configs = [ "//build/config/mac:strip_all" ]

      ldflags +=
          [ "-Wcrl,strip,-s," + rebase_path("app/app.saves", root_build_dir) ]
    }
  }

  bundle_data("chrome_framework_locales") {
    sources = []
    public_deps = [
      ":repack_locales_pack",
    ]

    foreach(locale, locales_as_mac_outputs) {
      sources += [ "$root_gen_dir/repack/locales/$locale.pak" ]
    }

    outputs = [
      "{{bundle_resources_dir}}/{{source_name_part}}.lproj/locale.pak",
    ]
  }

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

    outputs = [
      "{{bundle_root_dir}}/Helpers/{{source_file_part}}",
    ]

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

  bundle_data("chrome_framework_resources") {
    sources = [
      # This image is used to badge the lock icon in the
      # authentication dialogs, such as those used for installation
      # from disk image and Keystone promotion (if so enabled).  It
      # needs to exist as a file on disk and not just something in a
      # resource bundle because that's the interface that
      # Authorization Services uses.  Also, Authorization Services
      # can't deal with .icns files.
      "$root_gen_dir/repack/resources.pak",
      "$root_out_dir/app_mode_loader.app",
      "$root_out_dir/chrome_100_percent.pak",
      "$root_out_dir/icudtl.dat",
      "app/theme/default_100_percent/$branding_path_component/product_logo_32.png",
      "browser/mac/install.sh",
    ]

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

    public_deps = [
      ":packed_extra_resources",
      ":packed_resources",
      "//chrome/app_shim:app_mode_loader",
      "//third_party/icu:icudata",
    ]

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

    # TODO(estade): remove material design specific resources.
    # See crbug.com/613593
    if (is_mac) {
      sources += [ "$root_out_dir/chrome_material_100_percent.pak" ]

      if (enable_hidpi) {
        sources += [ "$root_out_dir/chrome_material_200_percent.pak" ]
      }
    }

    if (enable_mac_keystone) {
      sources += [
        "browser/mac/keystone_promote_postflight.sh",
        "browser/mac/keystone_promote_preflight.sh",
      ]
    }

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

  # When debug_devtools is enabled, symlink the inspector resources into the
  # framework bundle. The resources go into the final output directory for the
  # framework in the app bundle, rather than the framework bundle in
  # root_out_dir, since copy_bundle_data copies the contents of the link
  # rather than the link itself.
  action("devtools_debug_resources") {
    _stamp = "$target_out_dir/run_${target_name}.stamp"

    outputs = [
      _stamp,
    ]

    script = "//build/symlink.py"
    args = [
      "-f",
      "--touch",
      rebase_path(_stamp, root_out_dir),

      # Convert the symlink source and destination to an absolute paths, which
      # makes symlinking easier (now pwd manipulation).
      rebase_path("$root_out_dir/resources/inspector"),
      rebase_path(
          "$root_out_dir/$chrome_product_full_name.app/Contents/Versions/$chrome_version_full/$chrome_framework_name.framework/Resources/inspector"),
    ]

    deps = [
      # Depend on :chrome_app to ensure that the bundle is produced before
      # creating or destroying the symlink.
      ":chrome_app",
      "//third_party/WebKit/public:blink_devtools_frontend_resources",
    ]
  }

  if (enable_nacl) {
    bundle_data("chrome_framework_plugins") {
      sources = []
      outputs = [
        "{{bundle_root_dir}}/Internet Plug-Ins/{{source_file_part}}",
      ]
      public_deps = []

      if (enable_nacl) {
        sources += [ "$root_out_dir/nacl_irt_x86_64.nexe" ]
        public_deps += [ "//ppapi/native_client:irt" ]
      }
    }
  } else {
    group("chrome_framework_plugins") {
    }
  }

  if (is_chrome_branded) {
    bundle_data("flash_player_plugin") {
      sources = [
        "$root_out_dir/PepperFlash/PepperFlashPlayer.plugin",
        "$root_out_dir/PepperFlash/manifest.json",
      ]
      outputs = [
        "{{bundle_root_dir}}/Internet Plug-Ins/PepperFlash/{{source_file_part}}",
      ]
      public_deps = [
        "//third_party/adobe/flash:flapper_binaries",
      ]
    }

    bundle_data("widevine_cdm_library_binaries") {
      sources = [
        "$root_out_dir/$widevine_cdm_path/libwidevinecdm.dylib",
        "$root_out_dir/$widevine_cdm_path/widevinecdmadapter.plugin",
      ]
      outputs = [
        "{{bundle_root_dir}}/Libraries/$widevine_cdm_path/{{source_file_part}}",
      ]
      public_deps = [
        "//third_party/widevine/cdm:widevinecdm",
        "//third_party/widevine/cdm:widevinecdmadapter",
      ]
    }

    bundle_data("widevine_cdm_library_manifest") {
      sources = [
        "$root_out_dir/WidevineCdm/manifest.json",
      ]
      outputs = [
        "{{bundle_root_dir}}/Libraries/WidevineCdm/{{source_file_part}}",
      ]
      public_deps = [
        "//third_party/widevine/cdm:widevine_cdm_manifest",
      ]
    }
  } else {
    group("flash_player_plugin") {
    }
  }

  group("widevine_cdm_library") {
    if (is_chrome_branded) {
      deps = [
        ":widevine_cdm_library_binaries",
        ":widevine_cdm_library_manifest",
      ]
    }
  }

  if (enable_mac_keystone) {
    action("keystone_registration_framework") {
      script = "//chrome/tools/build/mac/copy_keystone_framework.py"

      framework_path = "//third_party/googlemac/Releases/Keystone/KeystoneRegistration.framework"
      output_path = "$root_out_dir/$chrome_framework_name.framework/Frameworks/"

      sources = [
        framework_path,
        script,
      ]

      args = [
        rebase_path(framework_path, root_out_dir),
        rebase_path(output_path, root_out_dir),
      ]

      outputs = [
        "$output_path/KeystoneRegistration.framework",
      ]
    }
  } else {
    group("keystone_registration_framework") {
    }
  }

  tweak_info_plist("chrome_framework_plist") {
    info_plist = "app/framework-Info.plist"
    _breakpad_uploads_arg = "0"
    if (enable_mac_crash_collection) {
      _breakpad_uploads_arg = "1"
    }
    args = [
      "--breakpad=1",
      "--breakpad_uploads=$_breakpad_uploads_arg",
      "--keystone=0",
      "--scm=1",
      "--branding",
      chrome_product_short_name,
    ]
  }

  # On Mac, speed up the component build by not re-bundling the framework
  # every time it changes. Instead, place all the sources and their deps in
  # a library that the bundled framework links (and re-exports). That way
  # only the library needs to be re-linked when it changes.
  if (is_component_build) {
    _dll_target_type = "shared_library"
  } else {
    _dll_target_type = "source_set"
  }
  target(_dll_target_type, "chrome_dll") {
    visibility = [
      ":chrome_framework",
      ":chrome_framework_shared_library",
    ]

    sources = [
      "app/chrome_command_ids.h",
      "app/chrome_crash_reporter_client.cc",
      "app/chrome_crash_reporter_client.h",
      "app/chrome_crash_reporter_client_mac.mm",
      "app/chrome_dll_resource.h",
      "app/chrome_main.cc",
      "app/chrome_main_delegate.cc",
      "app/chrome_main_delegate.h",
      "app/chrome_main_mac.h",
      "app/chrome_main_mac.mm",
    ]

    deps = [
      ":browser_dependencies",
      ":child_dependencies",
      "//chrome/common:features",
      "//components/crash/content/app",
      "//components/policy",
      "//content/public/app:both",
      "//third_party/cld_2",
    ]

    if (is_component_build) {
      libs = [ "Carbon.framework" ]
    }

    ldflags = [
      "-Wl,-order_file",
      "-Wl," + rebase_path("app/framework.order", root_build_dir),
      "-ObjC",
    ]

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

    if (enable_package_mash_services) {
      deps += [ "//chrome/app/mash" ]
    }
  }

  mac_framework_bundle("chrome_framework") {
    output_name = chrome_framework_name

    configs += [ "//build/config/compiler:wexit_time_destructors" ]

    info_plist_target = ":chrome_framework_plist"
    extra_substitutions = [
      "CHROMIUM_BUNDLE_ID=$chrome_mac_bundle_id",
      "CHROMIUM_SHORT_NAME=$chrome_product_short_name",
    ]

    public_deps = [
      ":chrome_dll",
    ]

    deps = [
      ":chrome_framework_helpers",
      ":chrome_framework_locales",
      ":chrome_framework_plugins",
      ":chrome_framework_resources",
      ":flash_player_plugin",
      ":widevine_cdm_library",
      "//build/config/sanitizers:deps",
      "//chrome/app/nibs:chrome_xibs",
    ]

    if (is_chrome_branded) {
      deps += [ ":default_apps" ]
    }

    ldflags = [
      "-Wl,-install_name,@executable_path/../Versions/$chrome_version_full/$chrome_framework_name.framework/$chrome_framework_name",
      "-compatibility_version",
      chrome_dylib_version,
      "-current_version",
      chrome_dylib_version,
      "-Wl,-order_file," + rebase_path("app/framework.order", root_build_dir),
    ]

    if (is_component_build) {
      ldflags += [
        "-rpath",
        "@loader_path/../../../../..",
        "-Wl,-reexport_library,libchrome_dll.dylib",
      ]

      data_deps = [
        ":chrome_dll",
      ]
    }
  }

  if (!is_asan && !is_component_build) {
    action("verify_chrome_framework_order") {
      script = "//chrome/tools/build/mac/run_verify_order.py"
      stamp_file = "$target_out_dir/run_$target_name.stamp"
      inputs = [
        script,
        "//chrome/tools/build/mac/verify_order",
      ]
      args = [
        "--stamp",
        rebase_path(stamp_file, root_out_dir),
        "_ChromeMain",
        rebase_path(
            "$root_out_dir/$chrome_framework_name.framework/$chrome_framework_name",
            root_out_dir),
      ]
      outputs = [
        stamp_file,
      ]
      public_deps = [
        ":chrome_framework",
      ]
    }
  } else {
    group("verify_chrome_framework_order") {
      public_deps = [
        ":chrome_framework",
      ]
    }
  }

  if (enable_dsyms) {
    # This list must be updated with the two targets' deps list below, and
    # the list of _dsyms in :chrome_dsym_archive.
    _chrome_symbols_sources = [
      "$root_out_dir/$chrome_framework_name.framework/$chrome_framework_name",
      "$root_out_dir/$chrome_helper_name.app/Contents/MacOS/$chrome_helper_name",
      "$root_out_dir/$chrome_product_full_name.app/Contents/MacOS/$chrome_product_full_name",
      "$root_out_dir/crashpad_handler",
    ]

    # It is possible to run dump_syms on unstripped products without dSYMs,
    # but doing so isn't logical and won't happen in practice.
    action_foreach("chrome_dump_syms") {
      script = "//build/redirect_stdout.py"

      sources = _chrome_symbols_sources

      outputs = [
        "$root_out_dir/{{source_file_part}}-$chrome_version_full.breakpad",
      ]

      # Use an aboslute path to dump_syms in case a user has it in their path.
      args = rebase_path(outputs, root_out_dir) + [
               rebase_path("$root_out_dir/dump_syms"),
               "-g",
               rebase_path(
                   "$root_out_dir/{{source_name_part}}.dSYM/Contents/Resources/DWARF/{{source_name_part}}",
                   root_out_dir),
               "{{source}}",
             ]

      deps = [
        ":chrome_app",
        ":chrome_framework",
        ":chrome_helper_app",
        "//breakpad:dump_syms",
        "//third_party/crashpad/crashpad/handler:crashpad_handler",
      ]
    }

    action("chrome_dsym_archive") {
      script = "//chrome/tools/build/mac/archive_symbols.py"

      # These are the dSYMs that will be archived. The sources list must be
      # are the target outputs that correspond to the dSYMs (since a dSYM is
      # a directory it cannot be listed as a source file). The targets that
      # generate both the dSYM and binary image are listed in deps.
      _dsyms = [
        "$root_out_dir/$chrome_framework_name.dSYM",
        "$root_out_dir/$chrome_helper_name.dSYM",
        "$root_out_dir/$chrome_product_full_name.dSYM",
        "$root_out_dir/crashpad_handler.dSYM",
      ]

      sources = _chrome_symbols_sources

      _output = "$root_out_dir/$chrome_product_full_name.dSYM.tar.bz2"

      outputs = [
        _output,
      ]

      args = [ rebase_path(_output, root_out_dir) ] +
             rebase_path(_dsyms, root_out_dir)

      deps = [
        ":chrome_app",
        ":chrome_framework",
        ":chrome_helper_app",
        "//third_party/crashpad/crashpad/handler:crashpad_handler",
      ]
    }
  } else {
    group("chrome_dump_syms") {
    }
    group("chrome_symbol_archive") {
    }
  }
}

# GYP version: chromium_browser_dependencies variable in chrome.gyp
group("browser_dependencies") {
  public_deps = [
    "//chrome/browser",
    "//chrome/common",
    "//sync",
  ]
  if (enable_plugins) {
    public_deps += [ "//ppapi/host" ]
  }

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

  if (!is_component_build) {
    assert_no_deps = [
      # Blink and V8 should not be used in the browser process. In component
      # build this is OK because all of content is linked into one library.
      # Note that the blink_headers target is OK, so we can't do a wildcard for
      # all blink targets.
      "//third_party/WebKit/public:blink",
      # TODO(brettw) bug 581766: V8 should not be linked into the browser
      # process, and then we can enable this.
      #"//v8/*",
    ]
  }
}

# GYP version: chromium_child_dependencies variable in chrome.gyp
group("child_dependencies") {
  public_deps = [
    "//chrome/common",
    "//sync",
  ]
  if (!is_ios) {
    public_deps += [
      "//chrome/browser/devtools",
      "//chrome/child",
      "//chrome/gpu",
      "//chrome/renderer",
      "//chrome/utility",
      "//content/public/child",
      "//third_party/WebKit/public:blink_devtools_frontend_resources",
    ]
  }

  if (enable_nacl) {
    public_deps += [ "//components/nacl/renderer/plugin:nacl_trusted_plugin" ]
  }
}

if (is_win) {
  process_version("chrome_exe_version") {
    template_file = chrome_version_rc_template
    sources = [
      "app/chrome_exe.ver",
    ]
    output = "$target_gen_dir/chrome_exe_version.rc"
  }

  process_version("chrome_dll_version") {
    template_file = chrome_version_rc_template
    sources = [
      "app/chrome_dll.ver",
    ]
    output = "$target_gen_dir/chrome_dll_version.rc"
  }

  # This manifest matches what GYP produces. It may not even be necessary.
  windows_manifest("chrome_dll_manifest") {
    sources = [
      as_invoker_manifest,
      common_controls_manifest,
    ]
    type = "dll"
  }

  process_version("nacl64_exe_version") {
    template_file = chrome_version_rc_template
    sources = [
      "app/nacl64_exe.ver",
    ]
    output = "$target_gen_dir/nacl64_exe_version.rc"
  }

  process_version("other_version") {
    template_file = chrome_version_rc_template
    sources = [
      "app/other.ver",
    ]
    output = "$target_gen_dir/other_version.rc"
  }

  source_set("file_pre_reader") {
    sources = [
      "app/file_pre_reader_win.cc",
      "app/file_pre_reader_win.h",
    ]
    deps = [
      "//base",
      "//components/startup_metric_utils/common",
    ]
  }
}

# GYP version: chrome/chrome_exe.gypi:visual_elements_resources
copy("visual_elements_resources") {
  sources = [
    "app/visual_elements_resources/Logo.png",
    "app/visual_elements_resources/SecondaryTile.png",
    "app/visual_elements_resources/SmallLogo.png",
    "app/visual_elements_resources/chrome.VisualElementsManifest.xml",
  ]

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

# GYP version: chrome/chrome_resources.gyp:chrome_resources
group("resources") {
  public_deps = [
    # Note: GYP lists some dependencies in addition to these actions. However,
    # these are just dependencies for the actions themselves, which our actions
    # list individually when needed.
    "//chrome/browser:resources",
    "//chrome/common:resources",
    "//chrome/renderer:resources",
  ]

  if (enable_extensions) {
    public_deps += [ "//chrome/common:extensions_api_resources" ]
  }
}

# GYP version: chrome/chrome_resources.gyp:chrome_extra_resources
group("extra_resources") {
  public_deps = [
    "//chrome/browser/resources:invalidations_resources",
    "//chrome/browser/resources:net_internals_resources",
    "//chrome/browser/resources:password_manager_internals_resources",
    "//chrome/browser/resources:policy_resources",
    "//chrome/browser/resources:translate_internals_resources",
  ]
  if (!is_ios) {
    public_deps += [
      "//chrome/browser/resources:component_extension_resources",
      "//chrome/browser/resources:options_resources",
      "//chrome/browser/resources:settings_resources",
    ]
  }

  if (is_chromeos) {
    public_deps += [ "//chrome/browser/resources/chromeos/chromevox" ]
  }

  if (enable_extensions) {
    public_deps += [
      "//chrome/browser/resources:quota_internals_resources",
      "//chrome/browser/resources:sync_file_system_internals_resources",
    ]
  }
}

if (is_chrome_branded) {
  if (!is_mac) {
    _default_apps_target_type = "copy"
  } else {
    _default_apps_target_type = "bundle_data"
  }

  target(_default_apps_target_type, "default_apps") {
    visibility = [ ":packed_resources" ]
    if (is_mac) {
      visibility += [
        ":chrome_framework",
        ":chrome_framework_shared_library",
      ]
    }

    sources = [
      "browser/resources/default_apps/docs.crx",
      "browser/resources/default_apps/drive.crx",
      "browser/resources/default_apps/external_extensions.json",
      "browser/resources/default_apps/gmail.crx",
      "browser/resources/default_apps/youtube.crx",
    ]

    if (!is_mac) {
      outputs = [
        "$root_out_dir/default_apps/{{source_file_part}}",
      ]
    } else {
      outputs = [
        "{{bundle_root_dir}}/Default Apps/{{source_file_part}}",
      ]
    }

    # Force anybody that depends on this to get the default apps as data files.
    data = process_file_template(sources, outputs)
  }
}

group("packed_resources") {
  public_deps = [
    ":repack_chrome_100_percent",
    ":repack_locales_pack",
    ":repack_pseudo_locales_pack",
  ]

  if (is_chrome_branded && !is_mac) {
    public_deps += [ ":default_apps" ]
  }

  if (enable_hidpi) {
    public_deps += [ ":repack_chrome_200_percent" ]
  }

  if (is_mac) {
    public_deps += [ ":repack_chrome_material_100_percent" ]

    if (enable_hidpi) {
      public_deps += [ ":repack_chrome_material_200_percent" ]
    }
  }
}

repack("packed_extra_resources") {
  visibility = [ "./*" ]
  sources = [
    "$root_gen_dir/chrome/browser_resources.pak",
    "$root_gen_dir/chrome/chrome_unscaled_resources.pak",
    "$root_gen_dir/chrome/common_resources.pak",
    "$root_gen_dir/chrome/invalidations_resources.pak",
    "$root_gen_dir/chrome/net_internals_resources.pak",
    "$root_gen_dir/chrome/password_manager_internals_resources.pak",
    "$root_gen_dir/chrome/policy_resources.pak",
    "$root_gen_dir/chrome/translate_internals_resources.pak",
    "$root_gen_dir/components/components_resources.pak",
    "$root_gen_dir/net/net_resources.pak",
    "$root_gen_dir/ui/resources/webui_resources.pak",
  ]
  deps = [
    "//chrome/app/theme:chrome_unscaled_resources",
    "//chrome/browser:resources",
    "//chrome/browser/resources:invalidations_resources",
    "//chrome/browser/resources:net_internals_resources",
    "//chrome/browser/resources:password_manager_internals_resources",
    "//chrome/browser/resources:policy_resources",
    "//chrome/browser/resources:translate_internals_resources",
    "//chrome/common:resources",
    "//components/resources",
    "//net:net_resources",
    "//ui/resources",
  ]

  if (!is_ios && !is_android) {
    # New paks should be added here by default.
    sources += [
      "$root_gen_dir/blink/devtools_resources.pak",
      "$root_gen_dir/chrome/component_extension_resources.pak",
      "$root_gen_dir/chrome/options_resources.pak",
      "$root_gen_dir/chrome/quota_internals_resources.pak",
      "$root_gen_dir/chrome/settings_resources.pak",
      "$root_gen_dir/chrome/sync_file_system_internals_resources.pak",
    ]
    deps += [
      "//chrome/browser/resources:component_extension_resources",
      "//chrome/browser/resources:options_resources",
      "//chrome/browser/resources:quota_internals_resources",
      "//chrome/browser/resources:settings_resources",
      "//chrome/browser/resources:sync_file_system_internals_resources",
      "//content/browser/devtools:devtools_resources",
    ]
  }
  if (!is_ios) {
    sources += [
      "$root_gen_dir/blink/public/resources/blink_resources.pak",
      "$root_gen_dir/content/browser/tracing/tracing_resources.pak",
      "$root_gen_dir/content/content_resources.pak",
    ]
    deps += [
      "//content:resources",
      "//content/browser/tracing:resources",
      "//third_party/WebKit/public:resources",
    ]
  }
  if (is_chromeos) {
    sources += [ "$root_gen_dir/ui/file_manager/file_manager_resources.pak" ]
    deps += [ "//ui/file_manager:resources" ]
  }
  if (enable_extensions) {
    sources += [
      "$root_gen_dir/chrome/extensions_api_resources.pak",
      "$root_gen_dir/extensions/extensions_renderer_resources.pak",
      "$root_gen_dir/extensions/extensions_resources.pak",
    ]
    deps += [
      "//chrome/common:extensions_api_resources",
      "//extensions:extensions_resources",
    ]
  }

  # GYP outputs the file in the gen/repack directory. On non-Mac/iOS platforms
  # it them copies it. This skipes the copy step and writes it to the final
  # location.
  if (is_mac || is_ios) {
    output = "$root_gen_dir/repack/resources.pak"
  } else {
    output = "$root_out_dir/resources.pak"
  }
}

# GYP version: chrome/chrome_resources.gyp:browser_tests_pak
repack("browser_tests_pak") {
  sources = [
    "$root_gen_dir/chrome/options_test_resources.pak",
    "$root_gen_dir/chrome/webui_test_resources.pak",
  ]
  output = "$root_out_dir/browser_tests.pak"
  deps = [
    "//chrome/browser/resources:options_test_resources",
    "//chrome/test/data:webui_test_resources",
  ]
}

# Collects per-locale grit files from many sources into global per-locale files.
chrome_repack_locales("repack_locales_pack") {
  visibility = [ ":*" ]

  input_locales = locales

  if (is_mac) {
    output_locales = locales_as_mac_outputs
  } else {
    output_locales = locales
  }
}

chrome_repack_locales("repack_pseudo_locales_pack") {
  visibility = [ ":*" ]

  input_locales = [ "fake-bidi" ]

  if (is_mac) {
    output_locales = [ "fake_bidi" ]  # Mac uses underscores.
  } else {
    output_locales = [ "fake-bidi" ]
  }
}

# Generates a rule to repack a set of resources, substituting a given string
# in for the percentage (e.g. "100", "200"). It generates the repacked files in
# the "gen" directory, and then introduces a copy rule to copy it to the root
# build directory.
#
# It's not clear why this two-step dance is necessary as opposed to just
# generating the file in the destination. However, this is what the GYP build
# does, and for maintenance purposes, this keeps the same files in the same
# place between the two builds when possible.
#
# Argument:
#   percent [required]
#      String to substitute for the percentage.
template("chrome_repack_percent") {
  percent = invoker.percent

  repack_name = "${target_name}_repack"
  repack_output_file = "$root_gen_dir/repack/chrome_${percent}_percent.pak"

  copy_name = target_name

  repack(repack_name) {
    visibility = [ ":$copy_name" ]

    # All sources should also have deps for completeness.
    sources = [
      "$root_gen_dir/chrome/renderer_resources_${percent}_percent.pak",
      "$root_gen_dir/chrome/theme_resources_${percent}_percent.pak",
      "$root_gen_dir/components/components_resources_${percent}_percent.pak",
      "$root_gen_dir/ui/resources/ui_resources_${percent}_percent.pak",
    ]

    deps = [
      "//chrome/app/theme:theme_resources",
      "//chrome/renderer:resources",
      "//components/resources",
      "//components/strings",
      "//net:net_resources",
      "//ui/resources",
    ]

    if (!is_ios) {
      sources += [
        "$root_gen_dir/blink/public/resources/blink_image_resources_${percent}_percent.pak",
        "$root_gen_dir/content/app/resources/content_resources_${percent}_percent.pak",
      ]
      deps += [
        "//content/app/resources",
        "//third_party/WebKit/public:image_resources",
      ]
    }
    if (use_ash) {
      sources +=
          [ "$root_gen_dir/ash/resources/ash_resources_${percent}_percent.pak" ]
      deps += [ "//ash/resources" ]
    }
    if (toolkit_views) {
      sources += [ "$root_gen_dir/ui/views/resources/views_resources_${percent}_percent.pak" ]
      deps += [ "//ui/views/resources" ]
    }
    if (is_chromeos) {
      sources += [ "$root_gen_dir/ui/chromeos/resources/ui_chromeos_resources_${percent}_percent.pak" ]
      deps += [ "//ui/chromeos/resources" ]
    }
    if (enable_extensions) {
      sources += [ "$root_gen_dir/extensions/extensions_browser_resources_${percent}_percent.pak" ]
      deps += [ "//extensions:extensions_browser_resources" ]
    }
    if (enable_app_list) {
      sources += [ "$root_gen_dir/ui/app_list/resources/app_list_resources_${percent}_percent.pak" ]
      deps += [ "//ui/app_list/resources" ]
    }

    output = repack_output_file
  }

  copy(copy_name) {
    visibility = [ ":*" ]
    deps = [
      ":$repack_name",
    ]
    sources = [
      repack_output_file,
    ]
    outputs = [
      "$root_build_dir/chrome_${percent}_percent.pak",
    ]
  }
}

chrome_repack_percent("repack_chrome_100_percent") {
  percent = "100"
}

if (enable_hidpi) {
  chrome_repack_percent("repack_chrome_200_percent") {
    percent = "200"
  }
}

# Generates a rule to repack a set of material design resources for the browser
# top chrome, substituting a given string in for the percentage (e.g. "100",
# "200").
template("chrome_repack_material_percent") {
  percent = invoker.percent

  repack_name = "${target_name}_repack"
  repack_output_file =
      "$root_gen_dir/repack/chrome_material_${percent}_percent.pak"

  copy_name = target_name

  repack(repack_name) {
    visibility = [ ":$copy_name" ]

    # All sources should also have deps for completeness.
    sources = [
      "$root_gen_dir/chrome/theme_resources_material_${percent}_percent.pak",
    ]

    deps = [
      "//chrome/app/theme:theme_resources",
      "//components/resources",
    ]

    output = repack_output_file
  }

  copy(copy_name) {
    visibility = [ ":*" ]
    deps = [
      ":$repack_name",
    ]
    sources = [
      repack_output_file,
    ]
    outputs = [
      "$root_build_dir/chrome_material_${percent}_percent.pak",
    ]
  }
}

if (is_mac) {
  chrome_repack_material_percent("repack_chrome_material_100_percent") {
    percent = "100"
  }

  if (enable_hidpi) {
    chrome_repack_material_percent("repack_chrome_material_200_percent") {
      percent = "200"
    }
  }
}

# GYP version: chrome/chrome_resources.gyp:chrome_strings
group("strings") {
  public_deps = [
    "//chrome/app:chromium_strings",
    "//chrome/app:generated_resources",
    "//chrome/app:google_chrome_strings",
    "//chrome/app:settings_chromium_strings",
    "//chrome/app:settings_google_chrome_strings",
    "//chrome/app:settings_strings",
    "//chrome/app/resources:locale_settings",
  ]
}

if (is_android) {
  # GYP: //chrome/chrome.gyp:data_use_ui_message_enum_java
  java_cpp_enum("data_use_ui_message_enum_javagen") {
    sources = [
      "browser/android/data_usage/data_use_tab_ui_manager_android.cc",
    ]
  }

  # GYP: //chrome/chrome.gyp:content_setting_java
  java_cpp_enum("content_setting_javagen") {
    sources = [
      "../components/content_settings/core/common/content_settings.h",
    ]
  }

  # GYP: //chrome/chrome.gyp:content_settings_type_java
  java_cpp_enum("content_settings_type_javagen") {
    sources = [
      "../components/content_settings/core/common/content_settings_types.h",
    ]
  }

  # GYP: //chrome/chrome.gyp:signin_metrics_enum_java
  java_cpp_enum("signin_metrics_enum_javagen") {
    sources = [
      "../components/signin/core/browser/signin_metrics.h",
    ]
  }

  # GYP: //chrome/chrome.gyp:page_info_connection_type_java
  java_cpp_enum("page_info_connection_type_javagen") {
    sources = [
      "browser/ui/android/website_settings_popup_android.h",
    ]
  }

  # GYP: //chrome/chrome.gyp:website_settings_action_java
  java_cpp_enum("website_settings_action_javagen") {
    sources = [
      "browser/ui/website_settings/website_settings.h",
    ]
  }

  # GYP: //chrome/chrome_android.gypi:chrome_android_core
  source_set("chrome_android_core") {
    sources = [
      "app/android/chrome_android_initializer.cc",
      "app/android/chrome_android_initializer.h",
      "app/android/chrome_jni_onload.cc",
      "app/android/chrome_jni_onload.h",
      "app/android/chrome_main_delegate_android.cc",
      "app/android/chrome_main_delegate_android.h",
      "app/chrome_main_delegate.cc",
      "app/chrome_main_delegate.h",
    ]

    include_dirs = [ android_ndk_include_dir ]

    libs = [
      "android",
      "jnigraphics",
    ]

    deps = [
      "//chrome/browser",
      "//chrome/browser/ui",
      "//chrome/child",
      "//chrome/common",
      "//chrome/gpu",
      "//chrome/renderer",
      "//chrome/utility",
      "//components/safe_browsing_db:safe_browsing_db_mobile",
      "//content/public/app:both",
    ]
  }
}

if (is_linux) {
  action("manpage") {
    if (is_chrome_branded) {
      name = "Google Chrome"
      filename = "google-chrome"
      confdir = "google-chrome"
    } else {
      name = "Chromium"
      filename = "chromium-browser"
      confdir = "chromium"
    }

    script = "//chrome/tools/build/linux/sed.py"
    infile = "app/resources/manpage.1.in"
    inputs = [
      infile,
    ]

    outfile = "$root_out_dir/chrome.1"
    outputs = [
      outfile,
    ]

    args = [
      rebase_path(infile, root_build_dir),
      rebase_path(outfile, root_build_dir),
      "-e s/@@NAME@@/$name/",
      "-e s/@@FILENAME@@/$filename/",
      "-e s/@@CONFDIR@@/$confdir/",
    ]
  }

  if (is_official_build) {
    action("linux_symbols") {
      script = "//build/linux/dump_app_syms.py"

      dump_syms_label = "//breakpad:dump_syms($host_toolchain)"
      dump_syms_binary =
          get_label_info(dump_syms_label, "root_out_dir") + "/" + "dump_syms"

      chrome_binary = "$root_out_dir/chrome"
      if (current_cpu == "x86") {
        # Use "ia32" instead of "x86" for GYP compat.
        symbol_file = "$root_out_dir/chrome.breakpad.ia32"
      } else {
        symbol_file = "$root_out_dir/chrome.breakpad.$current_cpu"
      }

      inputs = [
        chrome_binary,
        dump_syms_binary,
      ]
      outputs = [
        symbol_file,
      ]

      args = [
        "./" + rebase_path(dump_syms_binary, root_build_dir),
        "0",  # strip_binary = false
        rebase_path(chrome_binary, root_build_dir),
        rebase_path(symbol_file, root_build_dir),
      ]

      deps = [
        ":chrome",
        dump_syms_label,
      ]
    }
  }

  # Copies some scripts and resources that are used for desktop integration.
  copy("xdg_mime") {
    sources = [
      "//chrome/app/theme/$branding_path_component/product_logo_48.png",
      "//chrome/tools/build/linux/chrome-wrapper",
      "//third_party/xdg-utils/scripts/xdg-mime",
      "//third_party/xdg-utils/scripts/xdg-settings",
    ]
    outputs = [
      "$root_out_dir/{{source_file_part}}",
    ]
  }
}