Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 485 insertions, 0 deletions

diff --git a/third_party/libwebrtc/tools/grit/grit_rule.gni b/third_party/libwebrtc/tools/grit/grit_rule.gni
new file mode 100644
index 0000000000..fb107ef1a3
--- /dev/null
+++ b/third_party/libwebrtc/tools/grit/grit_rule.gni
@@ -0,0 +1,485 @@
+# 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.
+
+# Instantiate grit. This will produce a script target to run grit (named
+# ${target_name}_grit), and a static library that compiles the .cc files.
+#
+# In general, code should depend on the static library. However, if the
+# generated files are only processed by other actions to generate other
+# files, it is possible to depend on the script target directly.
+#
+# Parameters
+#
+#   source (required)
+#       Path to .grd file.
+#
+#   enable_input_discovery_for_gn_analyze (default=true)
+#       Runs grit_info.py via exec_script() when compute_inputs_for_analyze=true
+#       in order to discover all files that affect this target.
+#       Turn this off when the .grd file is generated, or an <include> with
+#       flattenhtml=true points to a generated file.
+#       For "gn analyze" to be correct with this arg disabled, all inputs
+#       must be listed via |inputs|.
+#
+#   inputs  (optional)
+#       List of additional files, required for grit to process source file.
+#
+#   outputs (required)
+#       List of outputs from grit, relative to the target_gen_dir. Grit will
+#       verify at build time that this list is correct and will fail if there
+#       is a mismatch between the outputs specified by the .grd file and the
+#       outputs list here.
+#
+#       To get this list, you can look in the .grd file for
+#       <output filename="..." and put those filename here. The base directory
+#       of the list in Grit and the output list specified in the GN grit target
+#       are the same (the target_gen_dir) so you can generally copy the names
+#       exactly.
+#
+#       To get the list of outputs programatically, run:
+#           python tools/grit/grit_info.py --outputs . path/to/your.grd
+#       And strip the leading "./" from the output files.
+#
+#   defines (optional)
+#       Extra defines to pass to grit (on top of the global grit_defines list).
+#
+#   grit_flags (optional)
+#       List of strings containing extra command-line flags to pass to Grit.
+#
+#   resource_ids (optional)
+#       Path to a grit "firstidsfile". Default is
+#       //tools/gritsettings/resource_ids. Set to "" to use the value specified
+#       in the <grit> nodes of the processed files.
+#
+#   output_dir (optional)
+#       Directory for generated files. If you specify this, you will often
+#       want to specify output_name if the target name is not particularly
+#       unique, since this can cause files from multiple grit targets to
+#       overwrite each other.
+#
+#   output_name (optional)
+#       Provide an alternate base name for the generated files, like the .d
+#       files. Normally these are based on the target name and go in the
+#       output_dir, but if multiple targets with the same name end up in
+#       the same output_dir, they can collide.
+#
+#   configs (optional)
+#       List of additional configs to be applied to the generated target.
+#
+#   deps  (optional)
+#   testonly (optional)
+#   visibility  (optional)
+#       Normal meaning.
+#
+# Example
+#
+#   grit("my_resources") {
+#     # Source and outputs are required.
+#     source = "myfile.grd"
+#     outputs = [
+#       "foo_strings.h",
+#       "foo_strings.pak",
+#     ]
+#
+#     grit_flags = [ "-E", "foo=bar" ]  # Optional extra flags.
+#     # You can also put deps here if the grit source depends on generated
+#     # files.
+#   }
+import("//build/config/chrome_build.gni")
+import("//build/config/chromeos/ui_mode.gni")
+import("//build/config/compiler/compiler.gni")
+import("//build/config/compute_inputs_for_analyze.gni")
+import("//build/config/crypto.gni")
+import("//build/config/features.gni")
+import("//build/config/sanitizers/sanitizers.gni")
+import("//build/config/ui.gni")
+import("//build/toolchain/gcc_toolchain.gni")
+
+declare_args() {
+  enable_resource_whitelist_generation = is_android && is_official_build
+}
+
+if (enable_resource_whitelist_generation) {
+  assert(target_os == "android" || target_os == "win",
+         "unsupported platform for resource whitelist generation")
+  assert(
+      symbol_level > 0 && !strip_debug_info && !is_component_build,
+      "resource whitelist generation only works on non-component builds with debug info enabled.")
+}
+
+grit_defines = []
+
+if (is_mac || is_win || is_linux || is_chromeos || is_ios) {
+  grit_defines += [
+    "-D",
+    "scale_factors=2x",
+  ]
+}
+
+# Mac and iOS want Title Case strings.
+use_titlecase_in_grd_files = is_apple
+if (use_titlecase_in_grd_files) {
+  grit_defines += [
+    "-D",
+    "use_titlecase",
+  ]
+}
+
+if (is_chrome_branded) {
+  grit_defines += [
+    "-D",
+    "_google_chrome",
+    "-E",
+    "CHROMIUM_BUILD=google_chrome",
+  ]
+} else {
+  grit_defines += [
+    "-D",
+    "_chromium",
+    "-E",
+    "CHROMIUM_BUILD=chromium",
+  ]
+}
+
+if (is_chromeos) {
+  grit_defines += [
+    "-D",
+    "chromeos",
+  ]
+}
+
+if (chromeos_is_browser_only) {
+  grit_defines += [
+    "-D",
+    "lacros",
+  ]
+}
+
+if (is_desktop_linux) {
+  grit_defines += [
+    "-D",
+    "desktop_linux",
+  ]
+}
+
+if (toolkit_views) {
+  grit_defines += [
+    "-D",
+    "toolkit_views",
+  ]
+}
+
+if (use_aura) {
+  grit_defines += [
+    "-D",
+    "use_aura",
+  ]
+}
+
+if (use_nss_certs) {
+  grit_defines += [
+    "-D",
+    "use_nss_certs",
+  ]
+}
+
+if (use_ozone) {
+  grit_defines += [
+    "-D",
+    "use_ozone",
+  ]
+}
+
+if (is_android) {
+  grit_defines += [
+    "-E",
+    "ANDROID_JAVA_TAGGED_ONLY=true",
+  ]
+}
+
+# When cross-compiling, explicitly pass the target system to grit.
+if (current_toolchain != host_toolchain) {
+  if (is_android) {
+    grit_defines += [
+      "-t",
+      "android",
+    ]
+  }
+  if (is_ios) {
+    grit_defines += [
+      "-t",
+      "ios",
+    ]
+  }
+  if (is_linux || is_chromeos) {
+    grit_defines += [
+      "-t",
+      "linux2",
+    ]
+  }
+  if (is_mac) {
+    grit_defines += [
+      "-t",
+      "darwin",
+    ]
+  }
+  if (is_win) {
+    grit_defines += [
+      "-t",
+      "win32",
+    ]
+  }
+}
+
+_strip_resource_files = is_android && is_official_build
+_js_minifier = "//tools/grit/minify_with_uglify.py"
+_css_minifier = "//tools/grit/minimize_css.py"
+
+grit_resource_id_target = "//tools/gritsettings:default_resource_ids"
+grit_resource_id_file =
+    get_label_info(grit_resource_id_target, "target_gen_dir") +
+    "/default_resource_ids"
+grit_info_script = "//tools/grit/grit_info.py"
+
+# TODO(asvitkine): Add predetermined ids files for other platforms.
+grit_predetermined_resource_ids_file = ""
+if (is_mac) {
+  grit_predetermined_resource_ids_file =
+      "//tools/gritsettings/startup_resources_mac.txt"
+}
+if (is_win) {
+  grit_predetermined_resource_ids_file =
+      "//tools/gritsettings/startup_resources_win.txt"
+}
+
+template("grit") {
+  if (defined(invoker.output_dir)) {
+    _output_dir = invoker.output_dir
+  } else {
+    _output_dir = target_gen_dir
+  }
+
+  _grit_outputs =
+      get_path_info(rebase_path(invoker.outputs, ".", _output_dir), "abspath")
+
+  # Add .info output for all pak files
+  _pak_info_outputs = []
+  foreach(output, _grit_outputs) {
+    if (get_path_info(output, "extension") == "pak") {
+      _pak_info_outputs += [ output + ".info" ]
+    }
+  }
+
+  if (defined(invoker.output_name)) {
+    _grit_output_name = invoker.output_name
+  } else {
+    _grit_output_name = target_name
+  }
+
+  _grit_custom_target = target_name + "_grit"
+  action(_grit_custom_target) {
+    testonly = defined(invoker.testonly) && invoker.testonly
+
+    script = "//tools/grit/grit.py"
+    depfile = "$target_gen_dir/$target_name.d"
+
+    inputs = [ invoker.source ]
+    deps = [ "//tools/grit:grit_sources" ]
+    outputs = [ "${depfile}.stamp" ] + _grit_outputs + _pak_info_outputs
+
+    _grit_flags = grit_defines
+
+    # Add extra defines with -D flags.
+    if (defined(invoker.defines)) {
+      foreach(i, invoker.defines) {
+        _grit_flags += [
+          "-D",
+          i,
+        ]
+      }
+    }
+
+    if (defined(invoker.grit_flags)) {
+      _grit_flags += invoker.grit_flags
+    }
+
+    _rebased_source_path = rebase_path(invoker.source, root_build_dir)
+    _enable_grit_info =
+        !defined(invoker.enable_input_discovery_for_gn_analyze) ||
+        invoker.enable_input_discovery_for_gn_analyze
+    if (_enable_grit_info && compute_inputs_for_analyze) {
+      # Only call exec_script when the user has explicitly opted into greater
+      # precision at the expense of performance.
+      _rel_inputs = exec_script("//tools/grit/grit_info.py",
+                                [
+                                      "--inputs",
+                                      _rebased_source_path,
+                                    ] + _grit_flags,
+                                "list lines")
+      inputs += rebase_path(_rel_inputs, ".", root_build_dir)
+    }
+
+    args = [
+             "-i",
+             _rebased_source_path,
+             "build",
+             "-o",
+             rebase_path(_output_dir, root_build_dir),
+             "--depdir",
+             ".",
+             "--depfile",
+             rebase_path(depfile, root_build_dir),
+             "--write-only-new=1",
+             "--depend-on-stamp",
+           ] + _grit_flags
+
+    # Add brotli executable if using brotli.
+    if (defined(invoker.use_brotli) && invoker.use_brotli) {
+      _brotli_target = "//third_party/brotli:brotli($host_toolchain)"
+      _brotli_executable = get_label_info(_brotli_target, "root_out_dir") +
+                           "/" + get_label_info(_brotli_target, "name")
+      if (host_os == "win") {
+        _brotli_executable += ".exe"
+      }
+
+      inputs += [ _brotli_executable ]
+      args += [
+        "--brotli",
+        rebase_path(_brotli_executable, root_build_dir),
+      ]
+    }
+
+    _resource_ids = grit_resource_id_file
+    if (defined(invoker.resource_ids)) {
+      _resource_ids = invoker.resource_ids
+    }
+
+    if (_resource_ids != "") {
+      inputs += [ _resource_ids ]
+      args += [
+        "-f",
+        rebase_path(_resource_ids, root_build_dir),
+      ]
+      if (_resource_ids == grit_resource_id_file) {
+        deps += [ grit_resource_id_target ]
+      }
+    }
+    if (grit_predetermined_resource_ids_file != "") {
+      inputs += [ grit_predetermined_resource_ids_file ]
+      args += [
+        "-p",
+        rebase_path(grit_predetermined_resource_ids_file, root_build_dir),
+      ]
+    }
+
+    # We want to make sure the declared outputs actually match what Grit is
+    # writing. We write the list to a file (some of the output lists are long
+    # enough to not fit on a Windows command line) and ask Grit to verify those
+    # are the actual outputs at runtime.
+    _asserted_list_file =
+        "$target_out_dir/${_grit_output_name}_expected_outputs.txt"
+    write_file(_asserted_list_file,
+               rebase_path(invoker.outputs, root_build_dir, _output_dir))
+    inputs += [ _asserted_list_file ]
+    args += [
+      "--assert-file-list",
+      rebase_path(_asserted_list_file, root_build_dir),
+    ]
+
+    if (enable_resource_whitelist_generation) {
+      _rc_grit_outputs = []
+      foreach(output, _grit_outputs) {
+        if (get_path_info(output, "extension") == "rc") {
+          _rc_grit_outputs += [ output ]
+        }
+      }
+
+      if (_rc_grit_outputs != []) {
+        # Resource whitelisting cannot be used with .rc files.
+        # Make sure that there aren't any .pak outputs which would require
+        # whitelist annotations.
+        assert(_pak_info_outputs == [], "can't combine .pak and .rc outputs")
+      } else {
+        args += [ "--whitelist-support" ]
+      }
+    }
+    if (_strip_resource_files) {
+      _js_minifier_command = rebase_path(_js_minifier, root_build_dir)
+      _css_minifier_command = rebase_path(_css_minifier, root_build_dir)
+      args += [
+        "--js-minifier",
+        _js_minifier_command,
+        "--css-minifier",
+        _css_minifier_command,
+      ]
+      inputs += [
+        _js_minifier,
+        _css_minifier,
+      ]
+    }
+
+    if (defined(invoker.visibility)) {
+      # This needs to include both what the invoker specified (since they
+      # probably include generated headers from this target), as well as the
+      # generated source set (since there's no guarantee that the visibility
+      # specified by the invoker includes our target).
+      #
+      # Only define visibility at all if the invoker specified it. Otherwise,
+      # we want to keep the public "no visibility specified" default.
+      visibility = [ ":${invoker.target_name}" ] + invoker.visibility
+    }
+
+    if (defined(invoker.use_brotli) && invoker.use_brotli) {
+      if (is_mac && is_asan) {
+        deps += [ "//tools/grit:brotli_mac_asan_workaround" ]
+      } else {
+        deps += [ "//third_party/brotli:brotli($host_toolchain)" ]
+      }
+    }
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
+    if (defined(invoker.inputs)) {
+      inputs += invoker.inputs
+    }
+  }
+
+  # This is the thing that people actually link with, it must be named the
+  # same as the argument the template was invoked with.
+  source_set(target_name) {
+    testonly = defined(invoker.testonly) && invoker.testonly
+
+    # Since we generate a file, we need to be run before the targets that
+    # depend on us.
+    sources = []
+    foreach(_output, _grit_outputs) {
+      _extension = get_path_info(_output, "extension")
+      if (_extension != "json" && _extension != "gz" && _extension != "pak" &&
+          _extension != "xml") {
+        sources += [ _output ]
+      }
+    }
+
+    # Deps set on the template invocation will go on the action that runs
+    # grit above rather than this library. This target needs to depend on the
+    # action publicly so other scripts can take the outputs from the grit
+    # script as inputs.
+    public_deps = [ ":$_grit_custom_target" ]
+
+    deps = [ "//base" ]
+
+    if (defined(invoker.public_configs)) {
+      public_configs += invoker.public_configs
+    }
+
+    if (defined(invoker.configs)) {
+      configs += invoker.configs
+    }
+
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+    output_name = _grit_output_name
+  }
+}