Pin depot_tools version for out-of-support branch

Use ScaleToRoundedRect instead of ScaleToEnclosedRect.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,35 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen and what happened instead.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Versions (please complete the following information):**
+ - OS: [e.g. Windows 10, MacOS 13.2, Ubuntu 22.10]
+ - CEF Version: [e.g. 111.2.2]
+
+**Additional context**
+Does the problem reproduce with the cefclient or cefsimple sample application at the same version?
+
+Does the problem reproduce with Google Chrome at the same version?
+
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -51,6 +51,5 @@ Thumbs.db
 /binary_distrib
 /docs
 # CEF generated files
-/include/cef_config.h
 /include/cef_version.h
 .ccls-cache/

CHROMIUM_BUILD_COMPATIBILITY.txt

@@ -7,6 +7,6 @@
 # https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
 
 {
-  'chromium_checkout': 'refs/tags/100.0.4896.127',
-  'depot_tools_checkout': '32645dfee9'
+  'chromium_checkout': 'refs/tags/130.0.6723.117',
+  'depot_tools_checkout': 'c22f4dc74f'
 }

CHROMIUM_UPDATE.txt

@@ -27,23 +27,11 @@
   # Files in the chromium/src directory that should be evaluated for changes.
   # Similar changes may need to be applied to the CEF source code.
   'files': [
-    'chrome/browser/browser_process.h',
-    'chrome/browser/extensions/api/tabs/tabs_api.*',
-    'chrome/browser/extensions/chrome_component_extension_resource_manager.*',
-    'chrome/browser/extensions/chrome_extension_web_contents_observer.*',
-    'chrome/browser/extensions/component_loader.*',
-    'chrome/browser/extensions/extension_service.*',
-    'chrome/browser/printing/print_view_manager*',
-    'chrome/browser/printing/printing_message_filter*',
-    'chrome/browser/profiles/profile.h',
-    'chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.*',
-    'chrome/common/extensions/api/*_features.json',
-    'chrome/renderer/chrome_content_renderer_client.*',
-    'chrome/renderer/extensions/chrome_extensions_renderer_client.*',
+    'components/content_settings/core/common/content_settings_types.mojom',
+    'components/permissions/request_type.h',
     'content/browser/renderer_host/render_widget_host_view_base.*',
     'content/public/browser/content_browser_client.*',
     'content/public/browser/render_widget_host_view.h',
-    'content/public/browser/storage_partition.h',
     'content/public/browser/web_contents_delegate.h',
     'content/public/common/content_features.cc',
     'content/shell/BUILD.gn',

CMakeLists.txt.in

@@ -12,8 +12,8 @@
 # distribution include:
 #
 # Linux:      Ninja, GCC 7.5.0+, Unix Makefiles
-# MacOS:      Ninja, Xcode 12.2 to 13.0
-# Windows:    Ninja, Visual Studio 2019+
+# MacOS:      Ninja, Xcode 12.2 to 15.0
+# Windows:    Ninja, Visual Studio 2022
 #
 # Ninja is a cross-platform open-source tool for running fast builds using
 # pre-installed platform toolchains (GNU, clang, Xcode or MSVC). It can be
@@ -36,7 +36,7 @@
 #
 # The below requirements must be met to build this CEF binary distribution.
 #
-# - CMake version 3.19 or newer.
+# - CMake version 3.21 or newer.
 #
 # - Linux requirements:
 #   Currently supported distributions include Debian 10 (Buster), Ubuntu 18
@@ -48,15 +48,14 @@
 #     libgtk3.0-dev     (required by the cefclient target only)
 #
 # - MacOS requirements:
-#   Xcode 12.2 to 13.0 building on MacOS 10.15.4 (Catalina) or newer. Only
-#   64-bit builds are supported. The Xcode command-line tools must also be
-#   installed. Newer Xcode versions may not have been been tested and are not
-#   recommended.
+#   Xcode 12.2 to 15.4 building on MacOS 11.0 (Big Sur) or newer. The Xcode
+#   command-line tools must also be installed. Newer Xcode versions may not have
+#   been been tested and are not recommended.
 #
 # - Windows requirements:
-#   Visual Studio 2019 or newer building on Windows 7 or newer. Windows 10
-#   64-bit is recommended. Newer versions will likely also work but may not have
-#   been tested.
+#   Visual Studio 2022 building on Windows 10 or newer. Windows 10/11 64-bit is
+#   recommended. Newer versions will likely also work but may not have been
+#   tested.
 #
 # BUILD EXAMPLES
 #
@@ -96,35 +95,35 @@
 #     > ninja cefclient cefsimple
 #
 # To perform a Windows build using a 32-bit CEF binary distribution:
-#   Using the Visual Studio 2019 IDE:
-#     > cmake -G "Visual Studio 16" -A Win32 ..
+#   Using the Visual Studio 2022 IDE:
+#     > cmake -G "Visual Studio 17" -A Win32 ..
 #     Open build\cef.sln in Visual Studio and select Build > Build Solution.
 #
-#   Using Ninja with Visual Studio 2019 command-line tools:
+#   Using Ninja with Visual Studio 2022 command-line tools:
 #     (this path may be different depending on your Visual Studio installation)
-#     > "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars32.bat"
+#     > "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvars32.bat"
 #     > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
 #     > ninja cefclient cefsimple
 #
 # To perform a Windows build using a 64-bit CEF binary distribution:
-#   Using the Visual Studio 2019 IDE:
-#     > cmake -G "Visual Studio 16" -A x64 ..
+#   Using the Visual Studio 2022 IDE:
+#     > cmake -G "Visual Studio 17" -A x64 ..
 #     Open build\cef.sln in Visual Studio and select Build > Build Solution.
 #
-#   Using Ninja with Visual Studio 2019 command-line tools:
+#   Using Ninja with Visual Studio 2022 command-line tools:
 #     (this path may be different depending on your Visual Studio installation)
-#     > "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
+#     > "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvars64.bat"
 #     > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
 #     > ninja cefclient cefsimple
 #
 # To perform a Windows build using an ARM64 CEF binary distribution:
-#   Using the Visual Studio 2019 IDE:
-#     > cmake -G "Visual Studio 16" -A arm64 ..
+#   Using the Visual Studio 2022 IDE:
+#     > cmake -G "Visual Studio 17" -A arm64 ..
 #     Open build\cef.sln in Visual Studio and select Build > Build Solution.
 #
-#   Using Ninja with Visual Studio 2019 command-line tools:
+#   Using Ninja with Visual Studio 2022 command-line tools:
 #     (this path may be different depending on your Visual Studio installation)
-#     > "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvarsamd64_arm64.bat"
+#     > "C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\Build\vcvarsamd64_arm64.bat"
 #     > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
 #     > ninja cefsimple
 
@@ -132,8 +131,8 @@
 # Global setup.
 #
 
-# For VS2019 and Xcode 12+ support.
-cmake_minimum_required(VERSION 3.19)
+# For VS2022 and Xcode 12+ support.
+cmake_minimum_required(VERSION 3.21)
 
 # Only generate Debug and Release configuration types.
 set(CMAKE_CONFIGURATION_TYPES Debug Release)
@@ -143,7 +142,7 @@ set(CMAKE_CONFIGURATION_TYPES Debug Release)
 project(cef)
 
 # Use folders in the resulting project files.
-set_property(GLOBAL PROPERTY OS_FOLDERS ON)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 
 #
@@ -234,3 +233,24 @@ endif()
 
 # Display configuration settings.
 PRINT_CEF_CONFIG()
+
+
+#
+# Define the API documentation target.
+#
+
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile")
+  find_package(Doxygen)
+  if(DOXYGEN_FOUND)
+    add_custom_target(apidocs ALL
+      # Generate documentation in the docs/html directory.
+      COMMAND "${DOXYGEN_EXECUTABLE}" Doxyfile
+      # Write a docs/index.html file.
+      COMMAND ${CMAKE_COMMAND} -E echo "<html><head><meta http-equiv=\"refresh\" content=\"0;URL='html/index.html'\"/></head></html>" > docs/index.html
+      WORKING_DIRECTORY "${CEF_ROOT}"
+      COMMENT "Generating API documentation with Doxygen..."
+      VERBATIM )
+  else()
+    message(WARNING "Doxygen must be installed to generate API documentation.")
+  endif()
+endif()

README.md

@@ -9,8 +9,8 @@ The Chromium Embedded Framework (CEF) is a simple framework for embedding Chromi
 * Branches and Building - https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
 * Announcements - https://groups.google.com/forum/#!forum/cef-announce
 * Support Forum - http://www.magpcss.org/ceforum/
-* CEF1 C++ API Docs - http://magpcss.org/ceforum/apidocs/
-* CEF3 C++ API Docs - http://magpcss.org/ceforum/apidocs3/
+* Issue Tracker - https://github.com/chromiumembedded/cef/issues
+* C++ API Docs - [Stable release docs](https://cef-builds.spotifycdn.com/docs/stable.html) / [Beta release docs](https://cef-builds.spotifycdn.com/docs/beta.html)
 * Downloads - https://cef-builds.spotifycdn.com/index.html
 * Donations - http://www.magpcss.org/ceforum/donate.php
 
@@ -29,7 +29,7 @@ Numerous individuals and organizations contribute time and resources to support
 
 # Getting Started
 
-Users new to CEF development should start by reading the [Tutorial](https://bitbucket.org/chromiumembedded/cef/wiki/Tutorial) Wiki page for an overview of CEF usage and then proceed to the [GeneralUsage](https://bitbucket.org/chromiumembedded/cef/wiki/GeneralUsage) Wiki page for a more in-depth discussion or architectural and usage issues. Complete API documentation is available [here](http://magpcss.org/ceforum/apidocs3/). CEF support and related discussion is available on the [CEF Forum](http://www.magpcss.org/ceforum/).
+Users new to CEF development should start by reading the [Tutorial](https://bitbucket.org/chromiumembedded/cef/wiki/Tutorial) Wiki page for an overview of CEF usage and then proceed to the [GeneralUsage](https://bitbucket.org/chromiumembedded/cef/wiki/GeneralUsage) Wiki page for a more in-depth discussion or architectural and usage issues. Complete API documentation is available [here](https://cef-builds.spotifycdn.com/docs/stable.html). CEF support and related discussion is available on the [CEF Forum](http://www.magpcss.org/ceforum/).
 
 # Binary Distributions
 
@@ -49,6 +49,7 @@ The base CEF framework includes support for the C and C++ programming languages.
 * Delphi - https://github.com/hgourvest/dcef3
 * Delphi - https://github.com/salvadordf/CEF4Delphi
 * Go - https://github.com/CzarekTomczak/cef2go
+* Go - https://github.com/energye/energy
 * Java - https://bitbucket.org/chromiumembedded/java-cef
 * Python - http://code.google.com/p/cefpython/
 
@@ -58,7 +59,7 @@ If you're the maintainer of a project not listed above and would like your proje
 
 CEF is still very much a work in progress. Some ways that you can help out:
 
-\- Vote for issues in the [CEF issue tracker](https://bitbucket.org/chromiumembedded/cef/issues?status=new&status=open) that are important to you. This helps with development prioritization.
+\- Vote for issues in the [CEF issue tracker](https://github.com/chromiumembedded/cef/issues) that are important to you. This helps with development prioritization.
 
 \- Report any bugs that you find or feature requests that are important to you. Make sure to first search for existing issues before creating new ones. Please use the [CEF Forum](http://magpcss.org/ceforum) and not the issue tracker for usage questions. Each CEF issue should:
 
@@ -69,7 +70,7 @@ CEF is still very much a work in progress. Some ways that you can help out:
 
 \- Write unit tests for new or existing functionality.
 
-\- Pull requests and patches are welcome. View open issues in the [CEF issue tracker](https://bitbucket.org/chromiumembedded/cef/issues?status=new&status=open) or search for TODO(cef) in the source code for ideas.
+\- Pull requests and patches are welcome. View open issues in the [CEF issue tracker](https://github.com/chromiumembedded/cef/issues) or search for TODO(cef) in the source code for ideas.
 
 If you would like to contribute source code changes to CEF please follow the below guidelines:
 
@@ -78,6 +79,6 @@ If you would like to contribute source code changes to CEF please follow the bel
 \- Submit a [pull request](https://bitbucket.org/chromiumembedded/cef/wiki/ContributingWithGit) or create a patch with your changes and attach it to the CEF issue. Changes should:
 
 * Be submitted against the current [CEF master branch](https://bitbucket.org/chromiumembedded/cef/src/?at=master) unless explicitly fixing a bug in a CEF release branch.
-* Follow the style of existing CEF source files. In general CEF uses the [Chromium coding style](http://www.chromium.org/developers/coding-style).
+* Follow the style of existing CEF source files. In general CEF uses the [Chromium C++ style guide](https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md).
 * Include new or modified unit tests as appropriate to the functionality.
 * Not include unnecessary or unrelated changes.

bazel/BUILD.bazel

@@ -0,0 +1,8 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+# Allow access from targets in other packages.
+package(default_visibility = [
+    "//visibility:public",
+])

bazel/copy_filegroups.bzl

@@ -0,0 +1,65 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+def _copy_filegroups_impl(ctx):
+    inputs = ctx.files.filegroups
+    remove_prefixes = ctx.attr.remove_prefixes
+    add_prefix = ctx.attr.add_prefix
+
+    outputs = []
+    for f in inputs:
+        relative_path = f.path
+        if relative_path.startswith("external/"):
+          # Remove the "external/<repo>" component, if any.
+          relative_path = "/".join(relative_path.split("/")[2:])
+
+        for prefix in remove_prefixes:
+            # Add trailing forward slash if necessary.
+            if prefix[-1] != "/":
+                prefix += "/"
+            if len(prefix) > 0 and relative_path.startswith(prefix):
+                relative_path = relative_path[len(prefix):]
+                break
+
+        if len(add_prefix) > 0:
+            # Add trailing forward slash if necessary.
+            if add_prefix[-1] != "/":
+                add_prefix += "/"
+            relative_path = add_prefix + relative_path
+
+        out = ctx.actions.declare_file(relative_path)
+        outputs.append(out)
+
+        if relative_path.find("/") > 0:
+            command="mkdir -p $(dirname {}) && cp {} {}".format(out.path, f.path, out.path)
+        else:
+            command="cp {} {}".format(f.path, out.path)
+
+        ctx.actions.run_shell(
+            outputs=[out],
+            inputs=depset([f]),
+            command=command
+        )
+
+    # Small sanity check
+    if len(inputs) != len(outputs):
+        fail("Output count should be 1-to-1 with input count.")
+
+    return DefaultInfo(
+        files=depset(outputs),
+        runfiles=ctx.runfiles(files=outputs)
+    )
+
+# Allows the file contents of |filegroups| to be copied next to a cc_binary
+# target via the |data| attribute.
+# Implementation based on https://stackoverflow.com/a/57983629
+copy_filegroups = rule(
+    implementation=_copy_filegroups_impl,
+    attrs={
+        "filegroups": attr.label_list(),
+        "remove_prefixes": attr.string_list(default = []),
+        "add_prefix": attr.string(default = ""),
+    },
+)
+

bazel/library_helpers.bzl

@@ -0,0 +1,90 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("//bazel/win:variables.bzl",
+     WIN_COMMON_COPTS="COMMON_COPTS",
+     WIN_COMMON_COPTS_RELEASE="COMMON_COPTS_RELEASE",
+     WIN_COMMON_COPTS_DEBUG="COMMON_COPTS_DEBUG",
+     WIN_COMMON_DEFINES="COMMON_DEFINES",
+     WIN_COMMON_DEFINES_RELEASE="COMMON_DEFINES_RELEASE",
+     WIN_COMMON_DEFINES_DEBUG="COMMON_DEFINES_DEBUG")
+load("//bazel/linux:variables.bzl",
+     LINUX_COMMON_COPTS="COMMON_COPTS",
+     LINUX_COMMON_COPTS_RELEASE="COMMON_COPTS_RELEASE",
+     LINUX_COMMON_COPTS_DEBUG="COMMON_COPTS_DEBUG",
+     LINUX_COMMON_DEFINES="COMMON_DEFINES",
+     LINUX_COMMON_DEFINES_RELEASE="COMMON_DEFINES_RELEASE",
+     LINUX_COMMON_DEFINES_DEBUG="COMMON_DEFINES_DEBUG")
+load("//bazel/mac:variables.bzl",
+     MAC_COMMON_COPTS="COMMON_COPTS",
+     MAC_COMMON_COPTS_RELEASE="COMMON_COPTS_RELEASE",
+     MAC_COMMON_COPTS_DEBUG="COMMON_COPTS_DEBUG")
+load("@rules_cc//cc:defs.bzl", "cc_library", "objc_library")
+
+def declare_cc_library(copts=[], local_defines=[], **kwargs):
+    """
+    cc_library wrapper that applies common copts and local_defines.
+    """
+    # NOTE: objc_library does not support local_defines on MacOS, so on
+    # that platform we put the defines in copts instead.
+    cc_library(
+        copts = select({
+            "@platforms//os:windows": WIN_COMMON_COPTS,
+            "@platforms//os:linux": LINUX_COMMON_COPTS,
+            "@platforms//os:macos": MAC_COMMON_COPTS,
+            "//conditions:default": None,
+        }) + select({
+            "@cef//:windows_opt": WIN_COMMON_COPTS_RELEASE,
+            "@cef//:windows_dbg": WIN_COMMON_COPTS_DEBUG,
+            "@cef//:windows_fastbuild": WIN_COMMON_COPTS_RELEASE,
+            "@cef//:linux_opt": LINUX_COMMON_COPTS_RELEASE,
+            "@cef//:linux_dbg": LINUX_COMMON_COPTS_DEBUG,
+            "@cef//:linux_fastbuild": LINUX_COMMON_COPTS_RELEASE,
+            "@cef//:macos_opt": MAC_COMMON_COPTS_RELEASE,
+            "@cef//:macos_dbg": MAC_COMMON_COPTS_DEBUG,
+            "@cef//:macos_fastbuild": MAC_COMMON_COPTS_RELEASE,
+            "//conditions:default": None,
+        }) + copts,
+        local_defines = select({
+            "@platforms//os:windows": WIN_COMMON_DEFINES,
+            "@platforms//os:linux": LINUX_COMMON_DEFINES,
+            "//conditions:default": None,
+        }) + select({
+            "@cef//:windows_opt": WIN_COMMON_DEFINES_RELEASE,
+            "@cef//:windows_dbg": WIN_COMMON_DEFINES_DEBUG,
+            "@cef//:windows_fastbuild": WIN_COMMON_DEFINES_RELEASE,
+            "@cef//:linux_opt": LINUX_COMMON_DEFINES_RELEASE,
+            "@cef//:linux_dbg": LINUX_COMMON_DEFINES_DEBUG,
+            "@cef//:linux_fastbuild": LINUX_COMMON_DEFINES_RELEASE,
+            "//conditions:default": None,
+        }) + local_defines,
+        **kwargs
+    )
+
+def declare_objc_library(copts=[], **kwargs):
+    """
+    objc_library wrapper that applies common copts.
+    """
+    # NOTE: objc_library does not support local_defines on MacOS, so on
+    # that platform we put the defines in copts instead.
+    objc_library(
+        copts = select({
+            "@platforms//os:windows": WIN_COMMON_COPTS,
+            "@platforms//os:linux": LINUX_COMMON_COPTS,
+            "@platforms//os:macos": MAC_COMMON_COPTS,
+            "//conditions:default": None,
+        }) + select({
+            "@cef//:windows_opt": WIN_COMMON_COPTS_RELEASE,
+            "@cef//:windows_dbg": WIN_COMMON_COPTS_DEBUG,
+            "@cef//:windows_fastbuild": WIN_COMMON_COPTS_RELEASE,
+            "@cef//:linux_opt": LINUX_COMMON_COPTS_RELEASE,
+            "@cef//:linux_dbg": LINUX_COMMON_COPTS_DEBUG,
+            "@cef//:linux_fastbuild": LINUX_COMMON_COPTS_RELEASE,
+            "@cef//:macos_opt": MAC_COMMON_COPTS_RELEASE,
+            "@cef//:macos_dbg": MAC_COMMON_COPTS_DEBUG,
+            "@cef//:macos_fastbuild": MAC_COMMON_COPTS_RELEASE,
+            "//conditions:default": None,
+        }) + copts,
+        **kwargs
+    )

bazel/linux/BUILD.bazel

@@ -0,0 +1,8 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+# Allow access from targets in other packages.
+package(default_visibility = [
+    "//visibility:public",
+])

bazel/linux/exe_helpers.bzl

@@ -0,0 +1,63 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("//bazel:copy_filegroups.bzl", "copy_filegroups")
+load("//bazel/linux:fix_rpath.bzl", "fix_rpath")
+load("//bazel/linux:variables.bzl",
+     "COMMON_LINKOPTS",
+     "COMMON_COPTS", "COMMON_COPTS_RELEASE", "COMMON_COPTS_DEBUG",
+     "COMMON_DEFINES", "COMMON_DEFINES_RELEASE", "COMMON_DEFINES_DEBUG")
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+
+def declare_exe(name, srcs=[], deps=[], linkopts=[], copts=[], local_defines=[], data=[], **kwargs):
+    # Copy SOs and resources into the current project.
+    copy_target = "{}_sos_and_resources".format(name)
+    copy_filegroups(
+        name = copy_target,
+        filegroups = [
+            "@cef//:sos",
+            "@cef//:resources",
+        ],
+        remove_prefixes = [
+            "Debug",
+            "Release",
+            "Resources",
+        ],
+    )
+
+    # Executable target.
+    binary_target = "{}_incorrect_rpath".format(name)
+    cc_binary(
+        name = binary_target,
+        srcs = srcs,
+        deps = [
+            "@cef//:cef_wrapper",
+            "@cef//:cef",
+            "@cef//:cef_sandbox",
+        ] + deps,
+        linkopts = COMMON_LINKOPTS + linkopts,
+        copts = COMMON_COPTS + select({
+            "@cef//:linux_dbg": COMMON_COPTS_DEBUG,
+            "//conditions:default": COMMON_COPTS_RELEASE,
+        }) + copts,
+        local_defines = COMMON_DEFINES + select({
+            "@cef//:linux_dbg": COMMON_DEFINES_DEBUG,
+            "//conditions:default": COMMON_DEFINES_RELEASE,
+        }) + local_defines,
+        data = [
+            ":{}".format(copy_target),
+        ] + data,
+        target_compatible_with = ["@platforms//os:linux"],
+        **kwargs
+    )
+
+    # Set rpath to $ORIGIN so that libraries can be loaded from next to the
+    # executable.
+    fix_rpath(
+        name = "{}_fixed_rpath".format(name),
+        src = ":{}".format(binary_target),
+        out = name,
+        target_compatible_with = ["@platforms//os:linux"],
+    )
+

bazel/linux/fix_rpath.bzl

@@ -0,0 +1,41 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+def _fix_rpath_impl(ctx):
+    inputs = ctx.runfiles(files = [ctx.file.src])
+    # Bring over 'data' dependencies from the input.
+    inputs = inputs.merge_all([ctx.attr.src[DefaultInfo].default_runfiles])
+
+    src = ctx.file.src.path
+    out = ctx.outputs.out.path
+
+    ctx.actions.run_shell(
+        outputs = [ctx.outputs.out],
+        inputs = inputs.files,
+        arguments = [src, out],
+        command = "cp $1 $2 && " +
+                  "chmod +w $2 && " +
+                  "patchelf --remove-rpath $2 && " +
+                  "patchelf --set-rpath '$ORIGIN' $2"
+    )
+
+    return [DefaultInfo(files = depset([ctx.outputs.out]))]
+
+# Set rpath to $ORIGIN so that libraries can be loaded from next to the
+# executable. The result can be confirmed with:
+# $ objdump -x ./bazel-bin/path/to/binary | grep 'R.*PATH'
+#
+# Alternatively, define a custom CC toolchain that overrides
+# 'runtime_library_search_directories'.
+#
+# This rule requires preinstallation of the patchelf package:
+# $ sudo apt install patchelf
+fix_rpath = rule(
+    implementation = _fix_rpath_impl,
+    attrs = {
+        "src": attr.label(allow_single_file = True),
+        "out": attr.output(mandatory = True),
+    },
+)
+

bazel/linux/pkg_config/BUILD.bazel

@@ -0,0 +1,7 @@
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "pkg_config.bzl",
+    "BUILD.tmpl",
+])
+

bazel/linux/pkg_config/BUILD.tmpl

@@ -0,0 +1,32 @@
+# vi: ft=bzl
+package(default_visibility = ["//visibility:private"])
+
+_imports = [p[:len(p)-2] for p in glob(["{}/**/*.a".format(d) for d in [%{deps}]])]
+[cc_import(
+    name = i.replace("/", "_"),
+    hdrs = glob([%{hdrs}]),
+    # TODO: library extension for platform.
+    static_library = "{}.a".format(i),
+    shared_library = "{}.dylib".format(i),
+) for i in _imports]
+
+cc_library(
+    name = "internal_lib",
+    hdrs = glob([%{hdrs}]),
+    copts = [%{copts}],
+    includes = [%{includes}],
+    linkopts = [%{linkopts}],
+    deps = [(":" + i.replace("/", "_")) for i in _imports],
+)
+
+cc_library(
+    name = "lib",
+    hdrs = glob(["%{strip_include}/**/*.h"]),
+    copts = [%{extra_copts}],
+    linkopts = [%{extra_linkopts}],
+    deps = [":internal_lib"] + [%{extra_deps}],
+    visibility = ["//visibility:public"],
+    strip_include_prefix = "%{strip_include}",
+    include_prefix = "%{include_prefix}",
+)
+

bazel/linux/pkg_config/README.cef

@@ -0,0 +1,11 @@
+Name: pkg_config
+URL: https://github.com/cherrry/bazel_pkg_config
+Version: 284219a
+
+Description:
+Bazel rules for pkg-config tools.
+
+CEF-specific changes:
+- Fix failure with duplicate symlinks.
+- Remove `--static` flag from pkg-config invocation.
+

bazel/linux/pkg_config/WORKSPACE

@@ -0,0 +1,2 @@
+workspace(name = "pkg_config")
+

bazel/linux/pkg_config/pkg_config.bzl

@@ -0,0 +1,194 @@
+def _success(value):
+    return struct(error = None, value = value)
+
+def _error(message):
+    return struct(error = message, value = None)
+
+def _split(result, delimeter = " "):
+    if result.error != None:
+        return result
+    return _success([arg for arg in result.value.strip().split(delimeter) if arg])
+
+def _find_binary(ctx, binary_name):
+    binary = ctx.which(binary_name)
+    if binary == None:
+        return _error("Unable to find binary: {}".format(binary_name))
+    return _success(binary)
+
+def _execute(ctx, binary, args):
+    result = ctx.execute([binary] + args)
+    if result.return_code != 0:
+        return _error("Failed execute {} {}".format(binary, args))
+    return _success(result.stdout)
+
+def _pkg_config(ctx, pkg_config, pkg_name, args):
+    return _execute(ctx, pkg_config, [pkg_name] + args)
+
+def _check(ctx, pkg_config, pkg_name):
+    exist = _pkg_config(ctx, pkg_config, pkg_name, ["--exists"])
+    if exist.error != None:
+        return _error("Package {} does not exist".format(pkg_name))
+
+    if ctx.attr.version != "":
+        version = _pkg_config(ctx, pkg_config, pkg_name, ["--exact-version", ctx.attr.version])
+        if version.error != None:
+            return _error("Require {} version = {}".format(pkg_name, ctx.attr.version))
+
+    if ctx.attr.min_version != "":
+        version = _pkg_config(ctx, pkg_config, pkg_name, ["--atleast-version", ctx.attr.min_version])
+        if version.error != None:
+            return _error("Require {} version >= {}".format(pkg_name, ctx.attr.min_version))
+
+    if ctx.attr.max_version != "":
+        version = _pkg_config(ctx, pkg_config, pkg_name, ["--max-version", ctx.attr.max_version])
+        if version.error != None:
+            return _error("Require {} version <= {}".format(pkg_name, ctx.attr.max_version))
+
+    return _success(None)
+
+def _extract_prefix(flags, prefix, strip = True):
+    stripped, remain = [], []
+    for arg in flags:
+        if arg.startswith(prefix):
+            if strip:
+                stripped += [arg[len(prefix):]]
+            else:
+                stripped += [arg]
+        else:
+            remain += [arg]
+    return stripped, remain
+
+def _includes(ctx, pkg_config, pkg_name):
+    includes = _split(_pkg_config(ctx, pkg_config, pkg_name, ["--cflags-only-I"]))
+    if includes.error != None:
+        return includes
+    includes, unused = _extract_prefix(includes.value, "-I", strip = True)
+    return _success(includes)
+
+def _copts(ctx, pkg_config, pkg_name):
+    return _split(_pkg_config(ctx, pkg_config, pkg_name, [
+        "--cflags-only-other",
+        "--libs-only-L",
+    ]))
+
+def _linkopts(ctx, pkg_config, pkg_name):
+    return _split(_pkg_config(ctx, pkg_config, pkg_name, [
+        "--libs-only-other",
+        "--libs-only-l",
+    ]))
+
+def _ignore_opts(opts, ignore_opts):
+    remain = []
+    for opt in opts:
+        if opt not in ignore_opts:
+            remain += [opt]
+    return remain
+
+def _symlinks(ctx, basename, srcpaths):
+    result = []
+    root = ctx.path("")
+    base = root.get_child(basename)
+    rootlen = len(str(base)) - len(basename)
+    for src in [ctx.path(p) for p in srcpaths]:
+        dest = base.get_child(src.basename)
+        if not dest.exists:
+            ctx.symlink(src, dest)
+        result += [str(dest)[rootlen:]]
+    return result
+
+def _deps(ctx, pkg_config, pkg_name):
+    deps = _split(_pkg_config(ctx, pkg_config, pkg_name, [
+        "--libs-only-L",
+        "--static",
+    ]))
+    if deps.error != None:
+        return deps
+    deps, unused = _extract_prefix(deps.value, "-L", strip = True)
+    result = []
+    for dep in {dep: True for dep in deps}.keys():
+        base = "deps_" + dep.replace("/", "_").replace(".", "_")
+        result += _symlinks(ctx, base, [dep])
+    return _success(result)
+
+def _fmt_array(array):
+    return ",".join(['"{}"'.format(a) for a in array])
+
+def _fmt_glob(array):
+    return _fmt_array(["{}/**/*.h".format(a) for a in array])
+
+def _pkg_config_impl(ctx):
+    pkg_name = ctx.attr.pkg_name
+    if pkg_name == "":
+        pkg_name = ctx.attr.name
+
+    pkg_config = _find_binary(ctx, "pkg-config")
+    if pkg_config.error != None:
+        return pkg_config
+    pkg_config = pkg_config.value
+
+    check = _check(ctx, pkg_config, pkg_name)
+    if check.error != None:
+        return check
+
+    includes = _includes(ctx, pkg_config, pkg_name)
+    if includes.error != None:
+        return includes
+    includes = includes.value
+    includes = _symlinks(ctx, "includes", includes)
+    strip_include = "includes"
+    if len(includes) == 1:
+        strip_include = includes[0]
+    if ctx.attr.strip_include != "":
+        strip_include += "/" + ctx.attr.strip_include
+
+    ignore_opts = ctx.attr.ignore_opts
+    copts = _copts(ctx, pkg_config, pkg_name)
+    if copts.error != None:
+        return copts
+    copts = _ignore_opts(copts.value, ignore_opts)
+
+    linkopts = _linkopts(ctx, pkg_config, pkg_name)
+    if linkopts.error != None:
+        return linkopts
+    linkopts = _ignore_opts(linkopts.value, ignore_opts)
+
+    deps = _deps(ctx, pkg_config, pkg_name)
+    if deps.error != None:
+        return deps
+    deps = deps.value
+
+    include_prefix = ctx.attr.name
+    if ctx.attr.include_prefix != "":
+        include_prefix = ctx.attr.include_prefix + "/" + ctx.attr.name
+
+    build = ctx.template("BUILD", Label("//:BUILD.tmpl"), substitutions = {
+        "%{name}": ctx.attr.name,
+        "%{hdrs}": _fmt_glob(includes),
+        "%{includes}": _fmt_array(includes),
+        "%{copts}": _fmt_array(copts),
+        "%{extra_copts}": _fmt_array(ctx.attr.copts),
+        "%{deps}": _fmt_array(deps),
+        "%{extra_deps}": _fmt_array(ctx.attr.deps),
+        "%{linkopts}": _fmt_array(linkopts),
+        "%{extra_linkopts}": _fmt_array(ctx.attr.linkopts),
+        "%{strip_include}": strip_include,
+        "%{include_prefix}": include_prefix,
+    }, executable = False)
+
+pkg_config = repository_rule(
+    attrs = {
+        "pkg_name": attr.string(doc = "Package name for pkg-config query, default to name."),
+        "include_prefix": attr.string(doc = "Additional prefix when including file, e.g. third_party. Compatible with strip_include option to produce desired include paths."),
+        "strip_include": attr.string(doc = "Strip prefix when including file, e.g. libs, files not included will be invisible. Compatible with include_prefix option to produce desired include paths."),
+        "version": attr.string(doc = "Exact package version."),
+        "min_version": attr.string(doc = "Minimum package version."),
+        "max_version": attr.string(doc = "Maximum package version."),
+        "deps": attr.string_list(doc = "Dependency targets."),
+        "linkopts": attr.string_list(doc = "Extra linkopts value."),
+        "copts": attr.string_list(doc = "Extra copts value."),
+        "ignore_opts": attr.string_list(doc = "Ignore listed opts in copts or linkopts."),
+    },
+    local = True,
+    implementation = _pkg_config_impl,
+)
+

bazel/linux/variables.bzl

@@ -0,0 +1,68 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+#
+# Distribution SOs.
+#
+
+SOS = [
+    "libcef.so",
+    "libEGL.so",
+    "libGLESv2.so",
+    "libvk_swiftshader.so",
+    "libvulkan.so.1",
+]
+
+#
+# Common 'linkopts' for cc_binary targets.
+#
+
+# Standard link libraries.
+STANDARD_LIBS = [
+    "X11",
+]
+
+COMMON_LINKOPTS_DEBUG = [
+]
+
+COMMON_LINKOPTS_RELEASE = [
+]
+
+COMMON_LINKOPTS = [
+    "-l{}".format(lib) for lib in STANDARD_LIBS
+]  + select({
+    "@cef//:linux_dbg": COMMON_LINKOPTS_DEBUG,
+    "//conditions:default": COMMON_LINKOPTS_RELEASE,
+})
+
+#
+# Common 'copts' for cc_libary and cc_binary targets.
+#
+
+COMMON_COPTS = [
+]
+
+COMMON_COPTS_DEBUG = [
+]
+
+COMMON_COPTS_RELEASE = [
+]
+
+#
+# Common 'defines' for cc_libary targets.
+#
+
+COMMON_DEFINES = [
+    # Used by apps to test if the sandbox is enabled
+    "CEF_USE_SANDBOX",
+]
+
+COMMON_DEFINES_DEBUG = [
+]
+
+COMMON_DEFINES_RELEASE = [
+    # Not a debug build
+    "NDEBUG",
+]
+

bazel/mac/BUILD.bazel

@@ -0,0 +1,8 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+# Allow access from targets in other packages.
+package(default_visibility = [
+    "//visibility:public",
+])

bazel/mac/app_helpers.bzl

@@ -0,0 +1,113 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("@bazel_skylib//rules:expand_template.bzl", "expand_template")
+load("@build_bazel_rules_apple//apple:macos.bzl", "macos_application")
+load("//bazel:variables.bzl", "VERSION_PLIST")
+load("//bazel/mac:variables.bzl",
+     "MACOS_DEPLOYMENT_TARGET",
+     "MACOS_BUNDLE_ID_BASE",
+     "CEF_FRAMEWORK_NAME",
+     "COMMON_LINKOPTS")
+
+def _declare_helper_app(name, info_plist, deps, helper_base_name, helper_suffix, **kwargs):
+    """
+    Creates a Helper .app target.
+    """
+    helper_name = "{} Helper".format(name)
+    bundle_id_suffix = ""
+
+    if helper_suffix:
+        helper_name += " ({})".format(helper_suffix)
+        bundle_id_suffix += ".{}".format(helper_suffix.lower())
+
+    # Helper app bundle Info.plist.
+    expand_template(
+        name = "{}_InfoPList".format(helper_base_name),
+        template = info_plist,
+        out = "{}Info.plist".format(helper_base_name),
+        substitutions = {
+            "${EXECUTABLE_NAME}": helper_name,
+            "${PRODUCT_NAME}": name,
+            "${BUNDLE_ID_SUFFIX}": bundle_id_suffix,
+            "${VERSION_SHORT}": VERSION_PLIST,
+            "${VERSION_LONG}": VERSION_PLIST,
+        },
+    )
+
+    # Helper app bundle.
+    macos_application(
+        name = helper_base_name,
+        bundle_name = helper_name,
+        bundle_id = "{}.{}.helper{}".format(MACOS_BUNDLE_ID_BASE, name.lower(), bundle_id_suffix),
+        infoplists = [":{}_InfoPList".format(helper_base_name)],
+        minimum_os_version = MACOS_DEPLOYMENT_TARGET,
+        deps = [
+            "@cef//:cef_sandbox",
+        ] + deps,
+        **kwargs,
+    )
+
+HELPERS = {
+    "HelperBase": "",
+    "HelperAlerts": "Alerts",
+    "HelperGPU": "GPU",
+    "HelperPlugin": "Plugin",
+    "HelperRenderer": "Renderer",
+}
+
+def declare_all_helper_apps(name, info_plist, deps, **kwargs):
+    """
+    Creates all Helper .app targets.
+    """
+    [_declare_helper_app(
+        name = name,
+        info_plist = info_plist,
+        deps = deps,
+        helper_base_name = h,
+        helper_suffix = v,
+        **kwargs,
+    ) for h, v in HELPERS.items()]
+
+def declare_main_app(name, info_plist, deps, resources, linkopts=[], **kwargs):
+    """
+    Creates the main .app target.
+    """
+
+    # Main app bundle Info.plist.
+    expand_template(
+        name = "InfoPList",
+        template = info_plist,
+        out = "Info.plist",
+        substitutions = {
+            "${EXECUTABLE_NAME}": name,
+            "${PRODUCT_NAME}": name,
+            "${VERSION_SHORT}": VERSION_PLIST,
+            "${VERSION_LONG}": VERSION_PLIST,
+        },
+    )
+
+    # Main app bindle.
+    macos_application(
+        name = name,
+        additional_contents = {
+            ":HelperBase": "Frameworks",
+            ":HelperAlerts": "Frameworks",
+            ":HelperGPU": "Frameworks",
+            ":HelperPlugin": "Frameworks",
+            ":HelperRenderer": "Frameworks",
+            "@cef//:cef_framework": "Frameworks/{}.framework".format(CEF_FRAMEWORK_NAME),
+        },
+        bundle_name = name,
+        bundle_id = "{}.{}".format(MACOS_BUNDLE_ID_BASE, name.lower()),
+        infoplists = [":InfoPList"],
+        linkopts = COMMON_LINKOPTS + linkopts,
+        minimum_os_version = MACOS_DEPLOYMENT_TARGET,
+        resources = resources,
+        target_compatible_with = [
+            "@platforms//os:macos",
+        ],
+        deps = deps,
+        **kwargs,
+    )

bazel/mac/variables.bzl

@@ -0,0 +1,52 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+MACOS_DEPLOYMENT_TARGET="11.0"
+MACOS_BUNDLE_ID_BASE="org.cef"
+CEF_FRAMEWORK_NAME="Chromium Embedded Framework"
+
+#
+# Common 'linkopts' for macos_application targets.
+#
+
+# Standard link frameworks.
+STANDARD_FRAMEWORKS = [
+    "AppKit",
+]
+
+COMMON_LINKOPTS_DEBUG = [
+]
+
+COMMON_LINKOPTS_RELEASE = [
+]
+
+COMMON_LINKOPTS = [
+    "-framework {}".format(lib) for lib in STANDARD_FRAMEWORKS
+]  + select({
+    "@cef//:macos_dbg": COMMON_LINKOPTS_DEBUG,
+    "//conditions:default": COMMON_LINKOPTS_RELEASE,
+})
+
+#
+# Common 'copts' for cc_libary, objc_library and macos_application targets.
+# We include defines in 'copts' because objc_library does not support
+# 'local_defines'. See https://github.com/bazelbuild/bazel/issues/17482.
+#
+
+COMMON_COPTS = [
+    "-Wno-undefined-var-template",
+    "-Wno-missing-field-initializers",
+    "-Wno-deprecated-copy",
+
+    # Used by apps to test if the sandbox is enabled
+    "-DCEF_USE_SANDBOX",
+]
+
+COMMON_COPTS_DEBUG = [
+]
+
+COMMON_COPTS_RELEASE = [
+    # Not a debug build
+    "-DNDEBUG",
+]

bazel/win/BUILD.bazel

@@ -0,0 +1,8 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+# Allow access from targets in other packages.
+package(default_visibility = [
+    "//visibility:public",
+])

bazel/win/cc_env.bzl

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain", _use_cpp_toolchain="use_cpp_toolchain")
+load("@rules_cc//cc:action_names.bzl", "CPP_COMPILE_ACTION_NAME")
+
+# Since we need windows.h and other headers, we should ensure we have the same
+# development environment as a regular cl.exe call. So use the current toolchain
+# to grab environment variables to feed into the actual rc.exe call
+# Much of this is taken from:
+#   https://github.com/bazelbuild/rules_cc/blob/main/examples/my_c_archive/my_c_archive.bzl
+def collect_compilation_env(ctx):
+    cc_toolchain = find_cpp_toolchain(ctx)
+    feature_configuration = cc_common.configure_features(
+        ctx = ctx,
+        cc_toolchain = cc_toolchain,
+        requested_features = ctx.features,
+        unsupported_features = ctx.disabled_features,
+    )
+
+    compiler_variables = cc_common.create_compile_variables(
+        feature_configuration = feature_configuration,
+        cc_toolchain = cc_toolchain,
+    )
+
+    return cc_common.get_environment_variables(
+      feature_configuration = feature_configuration,
+      action_name = CPP_COMPILE_ACTION_NAME,
+      variables = compiler_variables,
+    )
+
+use_cpp_toolchain=_use_cpp_toolchain

bazel/win/exe_helpers.bzl

@@ -0,0 +1,82 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("//bazel:copy_filegroups.bzl", "copy_filegroups")
+load("//bazel/win:mt.bzl", "add_manifest")
+load("//bazel/win:rc.bzl", "compile_rc")
+load("//bazel/win:variables.bzl",
+     "COMMON_LINKOPTS",
+     "COMMON_COPTS", "COMMON_COPTS_RELEASE", "COMMON_COPTS_DEBUG",
+     "COMMON_DEFINES", "COMMON_DEFINES_RELEASE", "COMMON_DEFINES_DEBUG")
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+
+def declare_exe(name, srcs, manifest_srcs, rc_file, resources_srcs, resources_deps=[],
+                deps=[], linkopts=[], copts=[], local_defines=[], data=[],
+                additional_linker_inputs=[], features=[], **kwargs):
+    # Resource file.
+    res_target = "{}_res".format(name)
+    compile_rc(
+        name = res_target,
+        rc_file = rc_file,
+        srcs = resources_srcs,
+        deps = resources_deps,
+        out = "{}.res".format(name),
+        target_compatible_with = ["@platforms//os:windows"],
+    )
+
+    # Copy DLLs and resources into the current project.
+    copy_target = "{}_dlls_and_resources".format(name)
+    copy_filegroups(
+        name = copy_target,
+        filegroups = [
+            "@cef//:dlls",
+            "@cef//:resources",
+        ],
+        remove_prefixes = [
+            "Debug",
+            "Release",
+            "Resources",
+        ],
+    )
+
+    # Executable target.
+    binary_target = "{}_no_manifest".format(name)
+    cc_binary(
+        name = binary_target,
+        srcs = srcs,
+        deps = [
+            "@cef//:cef_wrapper",
+            "@cef//:cef",
+            "@cef//:cef_sandbox",
+        ] + deps,
+        linkopts = [
+            "$(location :{})".format(res_target),
+        ] + COMMON_LINKOPTS + linkopts,
+        copts = COMMON_COPTS + select({
+            "@cef//:windows_dbg": COMMON_COPTS_DEBUG,
+            "//conditions:default": COMMON_COPTS_RELEASE,
+        }) + copts,
+        local_defines = COMMON_DEFINES + select({
+            "@cef//:windows_dbg": COMMON_DEFINES_DEBUG,
+            "//conditions:default": COMMON_DEFINES_RELEASE,
+        }) + local_defines,
+        additional_linker_inputs = [
+            ":{}".format(res_target),
+        ] + additional_linker_inputs,
+        data = [
+            ":{}".format(copy_target),
+        ] + data,
+        features = ["generate_pdb_file"] + features,
+        target_compatible_with = ["@platforms//os:windows"],
+        **kwargs
+    )
+
+    # Add manifest and rename to final executable.
+    add_manifest(
+        name = name,
+        mt_files = manifest_srcs,
+        in_binary = ":{}".format(binary_target),
+        out_binary = "{}.exe".format(name),
+        target_compatible_with = ["@platforms//os:windows"],
+    )

bazel/win/mt.bzl

@@ -0,0 +1,72 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("//bazel/win:cc_env.bzl", "collect_compilation_env", "use_cpp_toolchain")
+
+# Copy exe and pdb file without tracking the destination as an output.
+# Based on https://github.com/bazelbuild/bazel-skylib/blob/main/rules/private/copy_file_private.bzl
+def _write_copy_cmd(ctx, src, dst):
+    # Most Windows binaries built with MSVC use a certain argument quoting
+    # scheme. Bazel uses that scheme too to quote arguments. However,
+    # cmd.exe uses different semantics, so Bazel's quoting is wrong here.
+    # To fix that we write the command to a .bat file so no command line
+    # quoting or escaping is required.
+    bat = ctx.actions.declare_file(ctx.label.name + "-cmd.bat")
+    src_path = src.path.replace("/", "\\")
+    dst_path = dst.path.replace("/", "\\")
+    ctx.actions.write(
+        output = bat,
+        # Do not use lib/shell.bzl's shell.quote() method, because that uses
+        # Bash quoting syntax, which is different from cmd.exe's syntax.
+        content = "@copy /Y \"%s\" \"%s\" >NUL\n@copy /Y \"%s\" \"%s\" >NUL" % (
+            src_path,
+            dst_path,
+            src_path.replace(".exe", ".pdb"),
+            dst_path.replace(".exe", ".pdb"),
+        ),
+        is_executable = True,
+    )
+    return bat
+
+def _add_mt_impl(ctx):
+    mt_files = ctx.files.mt_files
+    input = ctx.attr.in_binary[DebugPackageInfo].unstripped_file
+    output = ctx.outputs.out_binary
+    bat = _write_copy_cmd(ctx, input, output)
+
+    inputs = mt_files + [input, bat]
+
+    # Bring over 'data' dependencies from the input.
+    deps_inputs =  ctx.runfiles(files = inputs)
+    deps_inputs = deps_inputs.merge_all([ctx.attr.in_binary[DefaultInfo].default_runfiles])
+
+    ctx.actions.run(
+        executable = ctx.executable._tool,
+        inputs = deps_inputs.files,
+        outputs = [output],
+        env = collect_compilation_env(ctx),
+        # The bat file will be executed before the tool command.
+        arguments = [bat.path, "-nologo", "-manifest"] + [f.path for f in mt_files] +
+                    ["-outputresource:{}".format(output.path)],
+        mnemonic = "AddMT"
+    )
+
+    return DefaultInfo(files = depset([output]))
+
+add_manifest = rule(
+    implementation = _add_mt_impl,
+    attrs = {
+        "mt_files": attr.label_list(allow_files = [".manifest"]),
+        "in_binary": attr.label(providers = [CcInfo], allow_single_file = True),
+        "out_binary": attr.output(),
+        "_cc_toolchain": attr.label(default = Label("@bazel_tools//tools/cpp:current_cc_toolchain")),
+        "_tool": attr.label(
+          default = "@winsdk//:mt_pybin",
+          executable = True,
+          cfg = "exec"
+        )
+    },
+    fragments = ["cpp"],
+    toolchains = use_cpp_toolchain(),
+)

bazel/win/rc.bzl

@@ -0,0 +1,50 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("//bazel/win:cc_env.bzl", "collect_compilation_env", "use_cpp_toolchain")
+
+def _compile_rc_impl(ctx):
+    rc_file = ctx.file.rc_file
+    output = ctx.outputs.out
+
+    inputs = [rc_file] + ctx.files.srcs
+    includes = ["/i{}/{}".format(ctx.label.package, i) for i in ctx.attr.includes]
+
+    # Grab all include paths/files required for the run
+    for dep in ctx.attr.deps:
+      comp_ctx = dep[CcInfo].compilation_context
+
+      includes += ["/i{}".format(i) for i in comp_ctx.quote_includes.to_list()]
+      includes += ["/i{}".format(i) for i in comp_ctx.system_includes.to_list()]
+      inputs += comp_ctx.headers.to_list()
+
+    ctx.actions.run(
+        executable = ctx.executable._tool,
+        inputs = inputs,
+        outputs = [output],
+        env = collect_compilation_env(ctx),
+        arguments = includes + ["/fo", output.path, rc_file.path],
+        mnemonic = "CompileRC"
+    )
+
+    return DefaultInfo(files = depset([output]))
+
+compile_rc = rule(
+    implementation = _compile_rc_impl,
+    attrs = {
+        "rc_file": attr.label(allow_single_file = [".rc"]),
+        "srcs": attr.label_list(allow_files = True),
+        "deps": attr.label_list(providers = [CcInfo]),
+        "includes": attr.string_list(),
+        "out": attr.output(),
+        "_cc_toolchain": attr.label(default = Label("@bazel_tools//tools/cpp:current_cc_toolchain")),
+        "_tool": attr.label(
+          default = "@winsdk//:rc_pybin",
+          executable = True,
+          cfg = "exec"
+        )
+    },
+    fragments = ["cpp"],
+    toolchains = use_cpp_toolchain(),
+)

bazel/win/setup_sdk.bzl

@@ -0,0 +1,124 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+load("@bazel_tools//tools/cpp:windows_cc_configure.bzl", "find_vc_path", "setup_vc_env_vars")
+
+def _get_arch(rctx):
+    if rctx.os.arch == "amd64":
+        return "x64"
+
+def _is_windows(rctx):
+    return rctx.os.name.find("windows") != -1
+
+# Tools in the form <Target>: [<Tool>, <Other files needed for that target>]
+TOOLS = {
+    "mt": {
+        "tool": "mt.exe",
+        "deps": [],
+    },
+    "rc": {
+        "tool": "rc.exe",
+        "deps": ["rcdll.dll"],
+    },
+}
+
+def _setup_tools(rctx, sdk_bin_path, sdk_metadata_path):
+    contents = ""
+
+    rctx.symlink(sdk_metadata_path, "VerUnionMetadata")
+    contents += """
+exports_files(["VerUnionMetadata"])
+"""
+
+    for toolname, toolcfg in TOOLS.items():
+        toolexec = toolcfg["tool"]
+        deps = toolcfg["deps"]
+        direct_deps = [toolexec] + deps
+        shared_deps = toolcfg.get("shared_deps", [])
+
+        # Symlink any tools into the right places
+        for dep in direct_deps:
+            rctx.symlink(
+                "{}/{}".format(sdk_bin_path, dep),
+                dep,
+            )
+
+        # Setting up a filegroup for those dependents
+        contents += """
+filegroup(
+  name = "{}_deps",
+  srcs = {},
+)
+""".format(toolname, direct_deps + shared_deps)
+
+        # Now create a wrapper for this tool that simply calls it
+        rctx.template(
+            "{}_wrapper.py".format(toolname),
+            Label("//bazel/win:wrapper.py.tpl"),
+            substitutions = {
+                "${binary}": toolexec,
+            },
+            executable = True,
+        )
+
+        # And add that newly created wrapper to the BUILD.bazel file
+        contents += """
+py_binary(
+    name = "{0}_pybin",
+    srcs = ["{0}_wrapper.py"],
+    main = "{0}_wrapper.py",
+    data = [
+        "@rules_python//python/runfiles",
+        ":{0}_deps"
+    ],
+    python_version = "PY3",
+)
+""".format(toolname)
+
+    return contents
+
+def _setup_vc_debug_runtime(rctx, sdk_bin_path):
+    ucrtbased_dll = "ucrtbased.dll"
+    rctx.symlink("{}/ucrt/{}".format(sdk_bin_path, ucrtbased_dll), ucrtbased_dll)
+
+    contents = """
+filegroup(
+    name = "vc_debug_runtime",
+    srcs = ["{}"],
+)
+""".format(ucrtbased_dll)
+
+    return contents
+
+def _windows_sdk_impl(rctx):
+    # We only support Windows
+    if not _is_windows(rctx):
+        fail("This rule only supports Windows")
+
+    # Figure out where the SDK is, which is based on a registry key.
+    vc_path = find_vc_path(rctx)
+    env = setup_vc_env_vars(rctx, vc_path, envvars = ["WINDOWSSDKVERBINPATH", "WindowsSdkDir", "WindowsSDKVersion"])
+    sdk_bin_path = "{}{}".format(env["WINDOWSSDKVERBINPATH"], _get_arch(rctx))
+    sdk_metadata_path = "{}UnionMetadata/{}".format(env["WindowsSdkDir"], env["WindowsSDKVersion"])
+
+    # Start with some pre-amble
+    contents = """# Autogenerated by //bazel/win:sdk.bzl
+load("@rules_python//python:defs.bzl", "py_binary")
+
+package(default_visibility = ["//visibility:public"])
+"""
+
+    # Handle setting up tools from our list
+    contents += _setup_tools(rctx, sdk_bin_path, sdk_metadata_path)
+
+    contents += _setup_vc_debug_runtime(rctx, sdk_bin_path)
+
+    rctx.file("BUILD.bazel", contents)
+
+setup_sdk = repository_rule(
+    attrs = {},
+    local = True,
+    configure = True,
+    implementation = _windows_sdk_impl,
+)

bazel/win/variables.bzl

@@ -0,0 +1,199 @@
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+#
+# Distribution DLLs.
+#
+
+# NOTE: libcef.dll is included via the //:cef dependency.
+DLLS = [
+    "chrome_elf.dll",
+    "d3dcompiler_47.dll",
+    "libEGL.dll",
+    "libGLESv2.dll",
+    "vk_swiftshader.dll",
+    "vulkan-1.dll",
+]
+
+DLLS_X64 = [
+    "dxil.dll",
+    "dxcompiler.dll",
+]
+
+#
+# Common 'linkopts' for cc_binary targets.
+#
+
+# Windows delayload DLLs.
+# Delayload most libraries as the DLLs are simply not required at startup (or
+# at all, depending on the process type). Some dlls open handles when they are
+# loaded, and we may not want them to be loaded in renderers or other sandboxed
+# processes. Conversely, some DLLs must be loaded before sandbox lockdown. In
+# unsandboxed processes they will load when first needed. The linker will
+# automatically ignore anything which is not linked to the binary at all (it is
+# harmless to have an unmatched /delayload). This list should be kept in sync
+# with Chromium's "delayloads" target from the //build/config/win/BUILD.gn file.
+DELAYLOAD_DLLS = [
+    "api-ms-win-core-winrt-error-l1-1-0.dll",
+    "api-ms-win-core-winrt-l1-1-0.dll",
+    "api-ms-win-core-winrt-string-l1-1-0.dll",
+    "advapi32.dll",
+    "comctl32.dll",
+    "comdlg32.dll",
+    "credui.dll",
+    "cryptui.dll",
+    "d3d11.dll",
+    "d3d9.dll",
+    "dwmapi.dll",
+    "dxgi.dll",
+    "dxva2.dll",
+    "esent.dll",
+    "gdi32.dll",
+    "hid.dll",
+    "imagehlp.dll",
+    "imm32.dll",
+    "msi.dll",
+    "netapi32.dll",
+    "ncrypt.dll",
+    "ole32.dll",
+    "oleacc.dll",
+    "propsys.dll",
+    "psapi.dll",
+    "rpcrt4.dll",
+    "rstrtmgr.dll",
+    "setupapi.dll",
+    "shell32.dll",
+    "shlwapi.dll",
+    "uiautomationcore.dll",
+    "urlmon.dll",
+    "user32.dll",
+    "usp10.dll",
+    "uxtheme.dll",
+    "wer.dll",
+    "wevtapi.dll",
+    "wininet.dll",
+    "winusb.dll",
+    "wsock32.dll",
+    "wtsapi32.dll",
+]
+
+# Standard link libraries.
+STANDARD_LIBS = [
+    "comctl32.lib",
+    "gdi32.lib",
+    "rpcrt4.lib",
+    "shlwapi.lib",
+    "user32.lib",
+    "ws2_32.lib",
+]
+
+# Sandbox link libraries.
+SANDBOX_LIBS = [
+    "Advapi32.lib",
+    "dbghelp.lib",
+    "Delayimp.lib",
+    "ntdll.lib",
+    "OleAut32.lib",
+    "PowrProf.lib",
+    "Propsys.lib",
+    "psapi.lib",
+    "SetupAPI.lib",
+    "Shcore.lib",
+    "Shell32.lib",
+    "Userenv.lib",
+    "version.lib",
+    "wbemuuid.lib",
+    "WindowsApp.lib",
+    "winmm.lib",
+]
+
+COMMON_LINKOPTS_DEBUG = [
+]
+
+COMMON_LINKOPTS_RELEASE = [
+]
+
+COMMON_LINKOPTS = [
+    # No default manifest (see compile_rc target).
+    "/MANIFEST:NO",
+    # Allow 32-bit processes to access 3GB of RAM.
+    "/LARGEADDRESSAWARE",
+    # Generate Debug information.
+    # TODO: Remove after fixing opt builds to work without it.
+    "/DEBUG",
+] + [
+    "/DELAYLOAD:{}".format(dll) for dll in DELAYLOAD_DLLS
+] + [
+    "/DEFAULTLIB:{}".format(lib) for lib in STANDARD_LIBS
+] + select({
+    # Set the initial stack size to 0.5MiB, instead of the 1.5MiB minimum
+    # needed by CEF'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. The main thread (in 32-bit builds
+    # only) uses fibers to switch to a 4MiB stack at runtime via
+    # CefRunWinMainWithPreferredStackSize().
+    "@cef//:windows_32": ["/STACK:0x80000"],
+    # Increase the initial stack size to 8MiB from the default 1MiB.
+    "//conditions:default": ["/STACK:0x800000"],
+}) + select({
+    "@cef//:windows_dbg": COMMON_LINKOPTS_DEBUG,
+    "//conditions:default": COMMON_LINKOPTS_RELEASE,
+})
+
+#
+# Common 'copts' for cc_libary and cc_binary targets.
+#
+
+COMMON_COPTS = [
+]
+
+COMMON_COPTS_DEBUG = [
+]
+
+COMMON_COPTS_RELEASE = [
+]
+
+#
+# Common 'defines' for cc_libary targets.
+#
+
+COMMON_DEFINES = [
+    # Windows platform
+    "WIN32",
+    "_WIN32",
+    "_WINDOWS",
+    # Unicode build           
+    "UNICODE",
+    "_UNICODE",
+    # Targeting Windows 10. We can't say `=_WIN32_WINNT_WIN10` here because
+    # some files do `#if WINVER < 0x0600` without including windows.h before,
+    # and then _WIN32_WINNT_WIN10 isn't yet known to be 0x0A00.
+    "WINVER=0x0A00",
+    "_WIN32_WINNT=0x0A00",
+    "NTDDI_VERSION=NTDDI_WIN10_FE",
+    # Use the standard's templated min/max
+    "NOMINMAX",
+    # Exclude less common API declarations
+    "WIN32_LEAN_AND_MEAN",
+    # Disable exceptions
+    "_HAS_EXCEPTIONS=0",
+
+    # Required by cef_sandbox.lib
+    "PSAPI_VERSION=1",
+    # Used by apps to test if the sandbox is enabled
+    "CEF_USE_SANDBOX",
+]
+
+COMMON_DEFINES_DEBUG = [
+    # Required by cef_sandbox.lib
+    # Disable iterator debugging
+    "HAS_ITERATOR_DEBUGGING=0",
+    "_ITERATOR_DEBUG_LEVEL=0",
+]
+
+COMMON_DEFINES_RELEASE = [
+    # Not a debug build
+    "NDEBUG",
+    "_NDEBUG",
+]

bazel/win/wrapper.py.tpl

@@ -0,0 +1,69 @@
+# Copyright (c) 2024 The Chromium Embedded Framework 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 os
+import subprocess
+import sys
+from rules_python.python.runfiles import runfiles
+
+REPLACEMENTS = {
+  "XXX_GETCWD_XXX": os.getcwd(),
+}
+
+def replace_in_str(input):
+  output = input
+  for placeholder, replacement in REPLACEMENTS.items():
+    if placeholder in output:
+      output = output.replace(placeholder, replacement)
+  return output
+
+def print_error(str):
+  print(str, file=sys.stderr)
+
+r = runfiles.Create()
+wrapped_binary = r.Rlocation("winsdk/${binary}")
+args = list(map(replace_in_str, sys.argv[1:]))
+
+# Optionally execute a script before tool execution.
+if args[0].endswith('.bat') or args[0].endswith('.cmd'):
+  if sys.platform != 'win32':
+    raise RuntimeError("Error running bat file; unsupported platform")
+
+  # Execute the .bat file first.
+  bat_file = args[0].replace('/', '\\')
+  p = subprocess.run(
+      bat_file, shell=True,
+      stdout = subprocess.PIPE,
+      stderr = subprocess.STDOUT,
+      text=True)
+  if p.returncode != 0:
+    print_error("[Generated python wrapper] Error running bat file:")
+    print_error(f"CWD: {os.getcwd()}")
+    print_error(f"EXEC: {bat_file}")
+    print_error(f"Exec output:")
+    print_error(p.stdout)
+    raise RuntimeError(f"Error running bat file; {bat_file}")
+
+  args = args[1:]
+
+try:
+  p = subprocess.run(
+      [wrapped_binary] + args,
+      stdout = subprocess.PIPE,
+      stderr = subprocess.STDOUT,
+      text=True)
+  if p.returncode != 0:
+    print_error("[Generated python wrapper] Error running command:")
+    print_error(f"CWD: {os.getcwd()}")
+    print_error(f"EXEC: {wrapped_binary}")
+    print_error(f"ARGS: {args}")
+    print_error(f"Exec output:")
+    print_error(p.stdout)
+    raise RuntimeError(f"Error running wrapped command; {wrapped_binary}")
+except OSError as e:
+  print_error("[Generated python wrapper] Error running command:")
+  print_error(f"CWD: {os.getcwd()}")
+  print_error(f"EXEC: {wrapped_binary}")
+  print_error(f"ARGS: {args}")
+  raise

cef_create_projects.bat

@@ -1,2 +1,2 @@
 @echo off
-python.bat tools\gclient_hook.py
+python3.bat tools\gclient_hook.py

cef_paths.gypi

@@ -1,4 +1,4 @@
-# Copyright (c) 2022 The Chromium Embedded Framework Authors. All rights
+# Copyright (c) 2024 The Chromium Embedded Framework Authors. All rights
 # reserved. Use of this source code is governed by a BSD-style license that
 # can be found in the LICENSE file.
 #
@@ -8,7 +8,7 @@
 # by hand. See the translator.README.txt file in the tools directory for
 # more information.
 #
-# $hash=3d75809bdc9a72a0df9df727981f0796b7ddbbc8$
+# $hash=e092ed49124ef5969b2052fd6ae5f6e6d89390ba$
 #
 
 {
@@ -22,6 +22,7 @@
       'include/cef_browser_process_handler.h',
       'include/cef_callback.h',
       'include/cef_client.h',
+      'include/cef_command_handler.h',
       'include/cef_command_line.h',
       'include/cef_context_menu_handler.h',
       'include/cef_cookie.h',
@@ -34,8 +35,6 @@
       'include/cef_download_item.h',
       'include/cef_drag_data.h',
       'include/cef_drag_handler.h',
-      'include/cef_extension.h',
-      'include/cef_extension_handler.h',
       'include/cef_file_util.h',
       'include/cef_find_handler.h',
       'include/cef_focus_handler.h',
@@ -54,6 +53,8 @@
       'include/cef_origin_whitelist.h',
       'include/cef_parser.h',
       'include/cef_path_util.h',
+      'include/cef_permission_handler.h',
+      'include/cef_preference.h',
       'include/cef_print_handler.h',
       'include/cef_print_settings.h',
       'include/cef_process_message.h',
@@ -73,13 +74,17 @@
       'include/cef_response_filter.h',
       'include/cef_scheme.h',
       'include/cef_server.h',
+      'include/cef_shared_memory_region.h',
+      'include/cef_shared_process_message_builder.h',
       'include/cef_ssl_info.h',
       'include/cef_ssl_status.h',
       'include/cef_stream.h',
       'include/cef_string_visitor.h',
       'include/cef_task.h',
+      'include/cef_task_manager.h',
       'include/cef_thread.h',
       'include/cef_trace.h',
+      'include/cef_unresponsive_process_callback.h',
       'include/cef_urlrequest.h',
       'include/cef_v8.h',
       'include/cef_values.h',
@@ -88,6 +93,7 @@
       'include/cef_xml_reader.h',
       'include/cef_zip_reader.h',
       'include/test/cef_test_helpers.h',
+      'include/test/cef_test_server.h',
       'include/test/cef_translator_test.h',
       'include/views/cef_box_layout.h',
       'include/views/cef_browser_view.h',
@@ -120,6 +126,7 @@
       'include/capi/cef_browser_process_handler_capi.h',
       'include/capi/cef_callback_capi.h',
       'include/capi/cef_client_capi.h',
+      'include/capi/cef_command_handler_capi.h',
       'include/capi/cef_command_line_capi.h',
       'include/capi/cef_context_menu_handler_capi.h',
       'include/capi/cef_cookie_capi.h',
@@ -132,8 +139,6 @@
       'include/capi/cef_download_item_capi.h',
       'include/capi/cef_drag_data_capi.h',
       'include/capi/cef_drag_handler_capi.h',
-      'include/capi/cef_extension_capi.h',
-      'include/capi/cef_extension_handler_capi.h',
       'include/capi/cef_file_util_capi.h',
       'include/capi/cef_find_handler_capi.h',
       'include/capi/cef_focus_handler_capi.h',
@@ -152,6 +157,8 @@
       'include/capi/cef_origin_whitelist_capi.h',
       'include/capi/cef_parser_capi.h',
       'include/capi/cef_path_util_capi.h',
+      'include/capi/cef_permission_handler_capi.h',
+      'include/capi/cef_preference_capi.h',
       'include/capi/cef_print_handler_capi.h',
       'include/capi/cef_print_settings_capi.h',
       'include/capi/cef_process_message_capi.h',
@@ -171,13 +178,17 @@
       'include/capi/cef_response_filter_capi.h',
       'include/capi/cef_scheme_capi.h',
       'include/capi/cef_server_capi.h',
+      'include/capi/cef_shared_memory_region_capi.h',
+      'include/capi/cef_shared_process_message_builder_capi.h',
       'include/capi/cef_ssl_info_capi.h',
       'include/capi/cef_ssl_status_capi.h',
       'include/capi/cef_stream_capi.h',
       'include/capi/cef_string_visitor_capi.h',
       'include/capi/cef_task_capi.h',
+      'include/capi/cef_task_manager_capi.h',
       'include/capi/cef_thread_capi.h',
       'include/capi/cef_trace_capi.h',
+      'include/capi/cef_unresponsive_process_callback_capi.h',
       'include/capi/cef_urlrequest_capi.h',
       'include/capi/cef_v8_capi.h',
       'include/capi/cef_values_capi.h',
@@ -186,6 +197,7 @@
       'include/capi/cef_xml_reader_capi.h',
       'include/capi/cef_zip_reader_capi.h',
       'include/capi/test/cef_test_helpers_capi.h',
+      'include/capi/test/cef_test_server_capi.h',
       'include/capi/test/cef_translator_test_capi.h',
       'include/capi/views/cef_box_layout_capi.h',
       'include/capi/views/cef_browser_view_capi.h',
@@ -242,6 +254,8 @@
       'libcef_dll/cpptoc/callback_cpptoc.h',
       'libcef_dll/ctocpp/client_ctocpp.cc',
       'libcef_dll/ctocpp/client_ctocpp.h',
+      'libcef_dll/ctocpp/command_handler_ctocpp.cc',
+      'libcef_dll/ctocpp/command_handler_ctocpp.h',
       'libcef_dll/cpptoc/command_line_cpptoc.cc',
       'libcef_dll/cpptoc/command_line_cpptoc.h',
       'libcef_dll/ctocpp/completion_callback_ctocpp.cc',
@@ -288,10 +302,6 @@
       'libcef_dll/ctocpp/drag_handler_ctocpp.h',
       'libcef_dll/ctocpp/end_tracing_callback_ctocpp.cc',
       'libcef_dll/ctocpp/end_tracing_callback_ctocpp.h',
-      'libcef_dll/cpptoc/extension_cpptoc.cc',
-      'libcef_dll/cpptoc/extension_cpptoc.h',
-      'libcef_dll/ctocpp/extension_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/extension_handler_ctocpp.h',
       'libcef_dll/cpptoc/file_dialog_callback_cpptoc.cc',
       'libcef_dll/cpptoc/file_dialog_callback_cpptoc.h',
       'libcef_dll/cpptoc/views/fill_layout_cpptoc.cc',
@@ -304,8 +314,6 @@
       'libcef_dll/cpptoc/frame_cpptoc.h',
       'libcef_dll/ctocpp/frame_handler_ctocpp.cc',
       'libcef_dll/ctocpp/frame_handler_ctocpp.h',
-      'libcef_dll/cpptoc/get_extension_resource_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/get_extension_resource_callback_cpptoc.h',
       'libcef_dll/cpptoc/image_cpptoc.cc',
       'libcef_dll/cpptoc/image_cpptoc.h',
       'libcef_dll/cpptoc/jsdialog_callback_cpptoc.cc',
@@ -324,6 +332,8 @@
       'libcef_dll/cpptoc/list_value_cpptoc.h',
       'libcef_dll/ctocpp/load_handler_ctocpp.cc',
       'libcef_dll/ctocpp/load_handler_ctocpp.h',
+      'libcef_dll/cpptoc/media_access_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/media_access_callback_cpptoc.h',
       'libcef_dll/ctocpp/media_observer_ctocpp.cc',
       'libcef_dll/ctocpp/media_observer_ctocpp.h',
       'libcef_dll/cpptoc/media_route_cpptoc.cc',
@@ -360,10 +370,18 @@
       'libcef_dll/ctocpp/views/panel_delegate_ctocpp.h',
       'libcef_dll/ctocpp/pdf_print_callback_ctocpp.cc',
       'libcef_dll/ctocpp/pdf_print_callback_ctocpp.h',
+      'libcef_dll/ctocpp/permission_handler_ctocpp.cc',
+      'libcef_dll/ctocpp/permission_handler_ctocpp.h',
+      'libcef_dll/cpptoc/permission_prompt_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/permission_prompt_callback_cpptoc.h',
       'libcef_dll/cpptoc/post_data_cpptoc.cc',
       'libcef_dll/cpptoc/post_data_cpptoc.h',
       'libcef_dll/cpptoc/post_data_element_cpptoc.cc',
       'libcef_dll/cpptoc/post_data_element_cpptoc.h',
+      'libcef_dll/cpptoc/preference_manager_cpptoc.cc',
+      'libcef_dll/cpptoc/preference_manager_cpptoc.h',
+      'libcef_dll/cpptoc/preference_registrar_cpptoc.cc',
+      'libcef_dll/cpptoc/preference_registrar_cpptoc.h',
       'libcef_dll/cpptoc/print_dialog_callback_cpptoc.cc',
       'libcef_dll/cpptoc/print_dialog_callback_cpptoc.h',
       'libcef_dll/ctocpp/print_handler_ctocpp.cc',
@@ -412,6 +430,8 @@
       'libcef_dll/cpptoc/run_context_menu_callback_cpptoc.h',
       'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.cc',
       'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.h',
+      'libcef_dll/cpptoc/run_quick_menu_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/run_quick_menu_callback_cpptoc.h',
       'libcef_dll/cpptoc/sslinfo_cpptoc.cc',
       'libcef_dll/cpptoc/sslinfo_cpptoc.h',
       'libcef_dll/cpptoc/sslstatus_cpptoc.cc',
@@ -430,6 +450,10 @@
       'libcef_dll/ctocpp/server_handler_ctocpp.h',
       'libcef_dll/ctocpp/set_cookie_callback_ctocpp.cc',
       'libcef_dll/ctocpp/set_cookie_callback_ctocpp.h',
+      'libcef_dll/cpptoc/shared_memory_region_cpptoc.cc',
+      'libcef_dll/cpptoc/shared_memory_region_cpptoc.h',
+      'libcef_dll/cpptoc/shared_process_message_builder_cpptoc.cc',
+      'libcef_dll/cpptoc/shared_process_message_builder_cpptoc.h',
       'libcef_dll/cpptoc/stream_reader_cpptoc.cc',
       'libcef_dll/cpptoc/stream_reader_cpptoc.h',
       'libcef_dll/cpptoc/stream_writer_cpptoc.cc',
@@ -438,8 +462,16 @@
       'libcef_dll/ctocpp/string_visitor_ctocpp.h',
       'libcef_dll/ctocpp/task_ctocpp.cc',
       'libcef_dll/ctocpp/task_ctocpp.h',
+      'libcef_dll/cpptoc/task_manager_cpptoc.cc',
+      'libcef_dll/cpptoc/task_manager_cpptoc.h',
       'libcef_dll/cpptoc/task_runner_cpptoc.cc',
       'libcef_dll/cpptoc/task_runner_cpptoc.h',
+      'libcef_dll/cpptoc/test/test_server_cpptoc.cc',
+      'libcef_dll/cpptoc/test/test_server_cpptoc.h',
+      'libcef_dll/cpptoc/test/test_server_connection_cpptoc.cc',
+      'libcef_dll/cpptoc/test/test_server_connection_cpptoc.h',
+      'libcef_dll/ctocpp/test/test_server_handler_ctocpp.cc',
+      'libcef_dll/ctocpp/test/test_server_handler_ctocpp.h',
       'libcef_dll/cpptoc/views/textfield_cpptoc.cc',
       'libcef_dll/cpptoc/views/textfield_cpptoc.h',
       'libcef_dll/ctocpp/views/textfield_delegate_ctocpp.cc',
@@ -472,6 +504,8 @@
       'libcef_dll/cpptoc/urlrequest_cpptoc.h',
       'libcef_dll/ctocpp/urlrequest_client_ctocpp.cc',
       'libcef_dll/ctocpp/urlrequest_client_ctocpp.h',
+      'libcef_dll/cpptoc/unresponsive_process_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/unresponsive_process_callback_cpptoc.h',
       'libcef_dll/ctocpp/v8accessor_ctocpp.cc',
       'libcef_dll/ctocpp/v8accessor_ctocpp.h',
       'libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.cc',
@@ -546,6 +580,8 @@
       'libcef_dll/ctocpp/callback_ctocpp.h',
       'libcef_dll/cpptoc/client_cpptoc.cc',
       'libcef_dll/cpptoc/client_cpptoc.h',
+      'libcef_dll/cpptoc/command_handler_cpptoc.cc',
+      'libcef_dll/cpptoc/command_handler_cpptoc.h',
       'libcef_dll/ctocpp/command_line_ctocpp.cc',
       'libcef_dll/ctocpp/command_line_ctocpp.h',
       'libcef_dll/cpptoc/completion_callback_cpptoc.cc',
@@ -592,10 +628,6 @@
       'libcef_dll/cpptoc/drag_handler_cpptoc.h',
       'libcef_dll/cpptoc/end_tracing_callback_cpptoc.cc',
       'libcef_dll/cpptoc/end_tracing_callback_cpptoc.h',
-      'libcef_dll/ctocpp/extension_ctocpp.cc',
-      'libcef_dll/ctocpp/extension_ctocpp.h',
-      'libcef_dll/cpptoc/extension_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/extension_handler_cpptoc.h',
       'libcef_dll/ctocpp/file_dialog_callback_ctocpp.cc',
       'libcef_dll/ctocpp/file_dialog_callback_ctocpp.h',
       'libcef_dll/ctocpp/views/fill_layout_ctocpp.cc',
@@ -608,8 +640,6 @@
       'libcef_dll/ctocpp/frame_ctocpp.h',
       'libcef_dll/cpptoc/frame_handler_cpptoc.cc',
       'libcef_dll/cpptoc/frame_handler_cpptoc.h',
-      'libcef_dll/ctocpp/get_extension_resource_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/get_extension_resource_callback_ctocpp.h',
       'libcef_dll/ctocpp/image_ctocpp.cc',
       'libcef_dll/ctocpp/image_ctocpp.h',
       'libcef_dll/ctocpp/jsdialog_callback_ctocpp.cc',
@@ -628,6 +658,8 @@
       'libcef_dll/ctocpp/list_value_ctocpp.h',
       'libcef_dll/cpptoc/load_handler_cpptoc.cc',
       'libcef_dll/cpptoc/load_handler_cpptoc.h',
+      'libcef_dll/ctocpp/media_access_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/media_access_callback_ctocpp.h',
       'libcef_dll/cpptoc/media_observer_cpptoc.cc',
       'libcef_dll/cpptoc/media_observer_cpptoc.h',
       'libcef_dll/ctocpp/media_route_ctocpp.cc',
@@ -664,10 +696,18 @@
       'libcef_dll/cpptoc/views/panel_delegate_cpptoc.h',
       'libcef_dll/cpptoc/pdf_print_callback_cpptoc.cc',
       'libcef_dll/cpptoc/pdf_print_callback_cpptoc.h',
+      'libcef_dll/cpptoc/permission_handler_cpptoc.cc',
+      'libcef_dll/cpptoc/permission_handler_cpptoc.h',
+      'libcef_dll/ctocpp/permission_prompt_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/permission_prompt_callback_ctocpp.h',
       'libcef_dll/ctocpp/post_data_ctocpp.cc',
       'libcef_dll/ctocpp/post_data_ctocpp.h',
       'libcef_dll/ctocpp/post_data_element_ctocpp.cc',
       'libcef_dll/ctocpp/post_data_element_ctocpp.h',
+      'libcef_dll/ctocpp/preference_manager_ctocpp.cc',
+      'libcef_dll/ctocpp/preference_manager_ctocpp.h',
+      'libcef_dll/ctocpp/preference_registrar_ctocpp.cc',
+      'libcef_dll/ctocpp/preference_registrar_ctocpp.h',
       'libcef_dll/ctocpp/print_dialog_callback_ctocpp.cc',
       'libcef_dll/ctocpp/print_dialog_callback_ctocpp.h',
       'libcef_dll/cpptoc/print_handler_cpptoc.cc',
@@ -716,6 +756,8 @@
       'libcef_dll/ctocpp/run_context_menu_callback_ctocpp.h',
       'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.cc',
       'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.h',
+      'libcef_dll/ctocpp/run_quick_menu_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/run_quick_menu_callback_ctocpp.h',
       'libcef_dll/ctocpp/sslinfo_ctocpp.cc',
       'libcef_dll/ctocpp/sslinfo_ctocpp.h',
       'libcef_dll/ctocpp/sslstatus_ctocpp.cc',
@@ -734,6 +776,10 @@
       'libcef_dll/cpptoc/server_handler_cpptoc.h',
       'libcef_dll/cpptoc/set_cookie_callback_cpptoc.cc',
       'libcef_dll/cpptoc/set_cookie_callback_cpptoc.h',
+      'libcef_dll/ctocpp/shared_memory_region_ctocpp.cc',
+      'libcef_dll/ctocpp/shared_memory_region_ctocpp.h',
+      'libcef_dll/ctocpp/shared_process_message_builder_ctocpp.cc',
+      'libcef_dll/ctocpp/shared_process_message_builder_ctocpp.h',
       'libcef_dll/ctocpp/stream_reader_ctocpp.cc',
       'libcef_dll/ctocpp/stream_reader_ctocpp.h',
       'libcef_dll/ctocpp/stream_writer_ctocpp.cc',
@@ -742,8 +788,16 @@
       'libcef_dll/cpptoc/string_visitor_cpptoc.h',
       'libcef_dll/cpptoc/task_cpptoc.cc',
       'libcef_dll/cpptoc/task_cpptoc.h',
+      'libcef_dll/ctocpp/task_manager_ctocpp.cc',
+      'libcef_dll/ctocpp/task_manager_ctocpp.h',
       'libcef_dll/ctocpp/task_runner_ctocpp.cc',
       'libcef_dll/ctocpp/task_runner_ctocpp.h',
+      'libcef_dll/ctocpp/test/test_server_ctocpp.cc',
+      'libcef_dll/ctocpp/test/test_server_ctocpp.h',
+      'libcef_dll/ctocpp/test/test_server_connection_ctocpp.cc',
+      'libcef_dll/ctocpp/test/test_server_connection_ctocpp.h',
+      'libcef_dll/cpptoc/test/test_server_handler_cpptoc.cc',
+      'libcef_dll/cpptoc/test/test_server_handler_cpptoc.h',
       'libcef_dll/ctocpp/views/textfield_ctocpp.cc',
       'libcef_dll/ctocpp/views/textfield_ctocpp.h',
       'libcef_dll/cpptoc/views/textfield_delegate_cpptoc.cc',
@@ -776,6 +830,8 @@
       'libcef_dll/ctocpp/urlrequest_ctocpp.h',
       'libcef_dll/cpptoc/urlrequest_client_cpptoc.cc',
       'libcef_dll/cpptoc/urlrequest_client_cpptoc.h',
+      'libcef_dll/ctocpp/unresponsive_process_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/unresponsive_process_callback_ctocpp.h',
       'libcef_dll/cpptoc/v8accessor_cpptoc.cc',
       'libcef_dll/cpptoc/v8accessor_cpptoc.h',
       'libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.cc',

cef_paths2.gypi

@@ -8,7 +8,6 @@
       'include/base/cef_atomic_flag.h',
       'include/base/cef_atomic_ref_count.h',
       'include/base/cef_auto_reset.h',
-      'include/base/cef_basictypes.h',
       'include/base/cef_bind.h',
       'include/base/cef_build.h',
       'include/base/cef_callback.h',
@@ -17,21 +16,20 @@
       'include/base/cef_callback_list.h',
       'include/base/cef_cancelable_callback.h',
       'include/base/cef_compiler_specific.h',
-      'include/base/cef_cxx17_backports.h',
+      'include/base/cef_dump_without_crashing.h',
       'include/base/cef_lock.h',
       'include/base/cef_logging.h',
       'include/base/cef_macros.h',
       'include/base/cef_platform_thread.h',
-      'include/base/cef_ptr_util.h',
       'include/base/cef_ref_counted.h',
       'include/base/cef_scoped_refptr.h',
-      'include/base/cef_template_util.h',
       'include/base/cef_thread_checker.h',
       'include/base/cef_trace_event.h',
       'include/base/cef_tuple.h',
       'include/base/cef_weak_ptr.h',
       'include/base/internal/cef_bind_internal.h',
       'include/base/internal/cef_callback_internal.h',
+      'include/base/internal/cef_color_id_macros.inc',
       'include/base/internal/cef_lock_impl.h',
       'include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h',
       'include/base/internal/cef_scoped_policy.h',
@@ -42,9 +40,11 @@
       'include/internal/cef_export.h',
       'include/internal/cef_ptr.h',
       'include/internal/cef_string_wrappers.h',
+      'include/internal/cef_time_wrappers.h',
       'include/internal/cef_types_wrappers.h',
     ],
     'includes_common_capi': [
+      'include/internal/cef_dump_without_crashing_internal.h',
       'include/internal/cef_logging_internal.h',
       'include/internal/cef_string.h',
       'include/internal/cef_string_list.h',
@@ -55,7 +55,10 @@
       'include/internal/cef_time.h',
       'include/internal/cef_trace_event_internal.h',
       'include/internal/cef_types.h',
+      'include/internal/cef_types_content_settings.h',
       'include/internal/cef_types_geometry.h',
+      'include/internal/cef_types_runtime.h',
+      'include/internal/cef_types_color.h',
     ],
     'includes_capi': [
       'include/capi/cef_base_capi.h',
@@ -79,6 +82,7 @@
       'include/internal/cef_win.h',
     ],
     'includes_win_capi': [
+      'include/internal/cef_app_win.h',
       'include/internal/cef_types_win.h',
     ],
     'includes_mac': [
@@ -121,6 +125,7 @@
       'libcef_dll/base/cef_atomic_flag.cc',
       'libcef_dll/base/cef_callback_helpers.cc',
       'libcef_dll/base/cef_callback_internal.cc',
+      'libcef_dll/base/cef_dump_without_crashing.cc',
       'libcef_dll/base/cef_lock.cc',
       'libcef_dll/base/cef_lock_impl.cc',
       'libcef_dll/base/cef_logging.cc',
@@ -147,6 +152,8 @@
       'libcef_dll/wrapper/cef_byte_read_handler.cc',
       'libcef_dll/wrapper/cef_closure_task.cc',
       'libcef_dll/wrapper/cef_message_router.cc',
+      'libcef_dll/wrapper/cef_message_router_utils.cc',
+      'libcef_dll/wrapper/cef_message_router_utils.h',
       'libcef_dll/wrapper/cef_resource_manager.cc',
       'libcef_dll/wrapper/cef_scoped_temp_dir.cc',
       'libcef_dll/wrapper/cef_stream_resource_handler.cc',
@@ -162,8 +169,6 @@
     'shared_sources_browser': [
       'tests/shared/browser/client_app_browser.cc',
       'tests/shared/browser/client_app_browser.h',
-      'tests/shared/browser/extension_util.cc',
-      'tests/shared/browser/extension_util.h',
       'tests/shared/browser/file_util.cc',
       'tests/shared/browser/file_util.h',
       'tests/shared/browser/geometry_util.cc',
@@ -177,12 +182,16 @@
       'tests/shared/browser/resource_util.h',
     ],
     'shared_sources_common': [
+      'tests/shared/common/binary_value_utils.cc',
+      'tests/shared/common/binary_value_utils.h',
       'tests/shared/common/client_app.cc',
       'tests/shared/common/client_app.h',
       'tests/shared/common/client_app_other.cc',
       'tests/shared/common/client_app_other.h',
       'tests/shared/common/client_switches.cc',
       'tests/shared/common/client_switches.h',
+      'tests/shared/common/string_util.cc',
+      'tests/shared/common/string_util.h',
     ],
     'shared_sources_renderer': [
       'tests/shared/renderer/client_app_renderer.cc',
@@ -214,6 +223,10 @@
       'tests/shared/browser/util_win.h',
     ],
     'cefclient_sources_browser': [
+      'tests/cefclient/browser/base_client_handler.cc',
+      'tests/cefclient/browser/base_client_handler.h',
+      'tests/cefclient/browser/binary_transfer_test.cc',
+      'tests/cefclient/browser/binary_transfer_test.h',
       'tests/cefclient/browser/binding_test.cc',
       'tests/cefclient/browser/binding_test.h',
       'tests/cefclient/browser/browser_window.cc',
@@ -229,9 +242,15 @@
       'tests/cefclient/browser/client_handler_osr.h',
       'tests/cefclient/browser/client_handler_std.cc',
       'tests/cefclient/browser/client_handler_std.h',
+      'tests/cefclient/browser/client_prefs.cc',
+      'tests/cefclient/browser/client_prefs.h',
       'tests/cefclient/browser/client_types.h',
+      'tests/cefclient/browser/default_client_handler.cc',
+      'tests/cefclient/browser/default_client_handler.h',
       'tests/cefclient/browser/dialog_test.cc',
       'tests/cefclient/browser/dialog_test.h',
+      'tests/cefclient/browser/hang_test.cc',
+      'tests/cefclient/browser/hang_test.h',
       'tests/cefclient/browser/image_cache.cc',
       'tests/cefclient/browser/image_cache.h',
       'tests/cefclient/browser/main_context.cc',
@@ -260,6 +279,8 @@
       'tests/cefclient/browser/scheme_test.h',
       'tests/cefclient/browser/server_test.cc',
       'tests/cefclient/browser/server_test.h',
+      'tests/cefclient/browser/task_manager_test.cc',
+      'tests/cefclient/browser/task_manager_test.h',
       'tests/cefclient/browser/temp_window.h',
       'tests/cefclient/browser/test_runner.cc',
       'tests/cefclient/browser/test_runner.h',
@@ -267,6 +288,8 @@
       'tests/cefclient/browser/urlrequest_test.h',
       'tests/cefclient/browser/views_menu_bar.cc',
       'tests/cefclient/browser/views_menu_bar.h',
+      'tests/cefclient/browser/views_overlay_browser.cc',
+      'tests/cefclient/browser/views_overlay_browser.h',
       'tests/cefclient/browser/views_overlay_controls.cc',
       'tests/cefclient/browser/views_overlay_controls.h',
       'tests/cefclient/browser/views_style.cc',
@@ -289,15 +312,20 @@
       'tests/cefclient/renderer/client_app_delegates_renderer.cc',
       'tests/cefclient/renderer/client_renderer.cc',
       'tests/cefclient/renderer/client_renderer.h',
+      'tests/cefclient/renderer/ipc_performance_test.cc',
+      'tests/cefclient/renderer/ipc_performance_test.h',
       'tests/cefclient/renderer/performance_test.cc',
       'tests/cefclient/renderer/performance_test.h',
       'tests/cefclient/renderer/performance_test_setup.h',
       'tests/cefclient/renderer/performance_test_tests.cc',
     ],
     'cefclient_sources_resources': [
+      'tests/cefclient/resources/binary_transfer.html',
       'tests/cefclient/resources/binding.html',
       'tests/cefclient/resources/dialogs.html',
       'tests/cefclient/resources/draggable.html',
+      'tests/cefclient/resources/hang.html',
+      'tests/cefclient/resources/ipc_performance.html',
       'tests/cefclient/resources/localstorage.html',
       'tests/cefclient/resources/logo.png',
       'tests/cefclient/resources/media_router.html',
@@ -309,19 +337,13 @@
       'tests/cefclient/resources/preferences.html',
       'tests/cefclient/resources/response_filter.html',
       'tests/cefclient/resources/server.html',
+      'tests/cefclient/resources/task_manager.html',
       'tests/cefclient/resources/transparency.html',
       'tests/cefclient/resources/urlrequest.html',
       'tests/cefclient/resources/websocket.html',
       'tests/cefclient/resources/window.html',
       'tests/cefclient/resources/xmlhttprequest.html',
     ],
-    'cefclient_sources_resources_extensions_set_page_color': [
-      'tests/cefclient/resources/extensions/set_page_color/icon.png',
-      'tests/cefclient/resources/extensions/set_page_color/manifest.json',
-      'tests/cefclient/resources/extensions/set_page_color/popup.html',
-      'tests/cefclient/resources/extensions/set_page_color/popup.js',
-      'tests/cefclient/resources/extensions/set_page_color/README.md',
-    ],
     'cefclient_sources_win': [
       'tests/cefclient/browser/browser_window_osr_win.cc',
       'tests/cefclient/browser/browser_window_osr_win.h',
@@ -357,12 +379,14 @@
       'tests/cefclient/browser/window_test_runner_win.cc',
       'tests/cefclient/browser/window_test_runner_win.h',
       'tests/cefclient/cefclient_win.cc',
-      'tests/cefclient/resources/win/cefclient.rc',
     ],
     'cefclient_sources_resources_win': [
-      'tests/cefclient/resources/win/cefclient.exe.manifest',
-      'tests/cefclient/resources/win/cefclient.ico',
-      'tests/cefclient/resources/win/small.ico',
+      'tests/cefclient/win/cefclient.exe.manifest',
+      'tests/cefclient/win/cefclient.ico',
+      'tests/cefclient/win/small.ico',
+    ],
+    'cefclient_sources_resources_win_rc': [
+      'tests/cefclient/win/cefclient.rc',
     ],
     'cefclient_sources_mac': [
       'tests/cefclient/browser/browser_window_osr_mac.h',
@@ -381,15 +405,16 @@
       'tests/cefclient/browser/temp_window_mac.mm',
       'tests/cefclient/browser/text_input_client_osr_mac.h',
       'tests/cefclient/browser/text_input_client_osr_mac.mm',
+      'tests/cefclient/browser/views_window_mac.mm',
       'tests/cefclient/browser/window_test_runner_mac.h',
       'tests/cefclient/browser/window_test_runner_mac.mm',
       'tests/cefclient/cefclient_mac.mm',
-   ],
+    ],
     'cefclient_bundle_resources_mac': [
-      'tests/cefclient/resources/mac/cefclient.icns',
-      'tests/cefclient/resources/mac/English.lproj/InfoPlist.strings',
-      'tests/cefclient/resources/mac/English.lproj/MainMenu.xib',
-      'tests/cefclient/resources/mac/Info.plist',
+      'tests/cefclient/mac/cefclient.icns',
+      'tests/cefclient/mac/English.lproj/InfoPlist.strings',
+      'tests/cefclient/mac/English.lproj/MainMenu.xib',
+      'tests/cefclient/mac/Info.plist.in',
     ],
     'cefclient_sources_linux': [
       'tests/cefclient/browser/browser_window_osr_gtk.cc',
@@ -421,15 +446,17 @@
       'tests/cefsimple/simple_handler.h',
     ],
     'cefsimple_sources_win': [
-      'tests/cefsimple/cefsimple.rc',
       'tests/cefsimple/cefsimple_win.cc',
-      'tests/cefsimple/simple_handler_win.cc',
       'tests/cefsimple/resource.h',
+      'tests/cefsimple/simple_handler_win.cc',
     ],
     'cefsimple_sources_resources_win': [
-      'tests/cefsimple/cefsimple.exe.manifest',
-      'tests/cefsimple/res/cefsimple.ico',
-      'tests/cefsimple/res/small.ico',
+      'tests/cefsimple/win/cefsimple.exe.manifest',
+      'tests/cefsimple/win/cefsimple.ico',
+      'tests/cefsimple/win/small.ico',
+    ],
+    'cefsimple_sources_resources_win_rc': [
+      'tests/cefsimple/win/cefsimple.rc',
     ],
     'cefsimple_sources_mac': [
       'tests/cefsimple/cefsimple_mac.mm',
@@ -442,15 +469,22 @@
       'tests/cefsimple/mac/cefsimple.icns',
       'tests/cefsimple/mac/English.lproj/InfoPlist.strings',
       'tests/cefsimple/mac/English.lproj/MainMenu.xib',
-      'tests/cefsimple/mac/Info.plist',
+      'tests/cefsimple/mac/Info.plist.in',
     ],
     'cefsimple_sources_linux': [
       'tests/cefsimple/cefsimple_linux.cc',
       'tests/cefsimple/simple_handler_linux.cc',
     ],
+    'ceftests_data_resources': [
+      'tests/ceftests/resources/net/data/ssl/certificates/expired_cert.pem',
+      'tests/ceftests/resources/net/data/ssl/certificates/localhost_cert.pem',
+      'tests/ceftests/resources/net/data/ssl/certificates/ok_cert.pem',
+      'tests/ceftests/resources/net/data/ssl/certificates/root_ca_cert.pem',
+    ],
     'ceftests_sources_common': [
       'tests/ceftests/audio_output_unittest.cc',
       'tests/ceftests/browser_info_map_unittest.cc',
+      'tests/ceftests/certificate_error_unittest.cc',
       'tests/ceftests/command_line_unittest.cc',
       'tests/ceftests/cookie_unittest.cc',
       'tests/ceftests/cors_unittest.cc',
@@ -460,28 +494,30 @@
       'tests/ceftests/dom_unittest.cc',
       'tests/ceftests/download_unittest.cc',
       'tests/ceftests/draggable_regions_unittest.cc',
-      'tests/ceftests/extensions/background_unittest.cc',
-      'tests/ceftests/extensions/chrome_alarms_unittest.cc',
-      'tests/ceftests/extensions/chrome_storage_unittest.cc',
-      'tests/ceftests/extensions/chrome_tabs_unittest.cc',
-      'tests/ceftests/extensions/extension_test_handler.cc',
-      'tests/ceftests/extensions/extension_test_handler.h',
-      'tests/ceftests/extensions/view_unittest.cc',
       'tests/ceftests/file_util_unittest.cc',
       'tests/ceftests/frame_handler_unittest.cc',
       'tests/ceftests/frame_unittest.cc',
+      'tests/ceftests/hsts_redirect_unittest.cc',
       'tests/ceftests/image_unittest.cc',
       'tests/ceftests/image_util.cc',
       'tests/ceftests/image_util.h',
       'tests/ceftests/jsdialog_unittest.cc',
       'tests/ceftests/life_span_unittest.cc',
-      'tests/ceftests/message_router_unittest.cc',
+      'tests/ceftests/media_access_unittest.cc',
+      'tests/ceftests/message_router_binary_unittest.cc',
+      'tests/ceftests/message_router_harness_unittest.cc',
+      'tests/ceftests/message_router_multi_query_unittest.cc',
+      'tests/ceftests/message_router_single_query_unittest.cc',
+      'tests/ceftests/message_router_threshold_unittest.cc',
+      'tests/ceftests/message_router_unittest_utils.cc',
+      'tests/ceftests/message_router_unittest_utils.h',
       'tests/ceftests/navigation_unittest.cc',
       'tests/ceftests/os_rendering_unittest.cc',
       'tests/ceftests/osr_accessibility_unittest.cc',
       'tests/ceftests/osr_display_unittest.cc',
       'tests/ceftests/parser_unittest.cc',
       'tests/ceftests/pdf_viewer_unittest.cc',
+      'tests/ceftests/permission_prompt_unittest.cc',
       'tests/ceftests/preference_unittest.cc',
       'tests/ceftests/print_unittest.cc',
       'tests/ceftests/process_message_unittest.cc',
@@ -498,6 +534,8 @@
       'tests/ceftests/scheme_handler_unittest.cc',
       'tests/ceftests/scoped_temp_dir_unittest.cc',
       'tests/ceftests/server_unittest.cc',
+      'tests/ceftests/send_shared_process_message_unittest.cc',
+      "tests/ceftests/shared_process_message_unittest.cc",
       'tests/ceftests/stream_unittest.cc',
       'tests/ceftests/stream_resource_handler_unittest.cc',
       'tests/ceftests/string_unittest.cc',
@@ -509,11 +547,21 @@
       'tests/ceftests/test_request.h',
       'tests/ceftests/test_server.cc',
       'tests/ceftests/test_server.h',
+      'tests/ceftests/test_server_observer.h',
+      'tests/ceftests/test_server_observer.cc',
+      'tests/ceftests/test_server_observer_unittest.cc',
+      'tests/ceftests/test_server_manager.h',
+      'tests/ceftests/test_server_manager.cc',
+      'tests/ceftests/test_server_runner.h',
+      'tests/ceftests/test_server_runner.cc',
+      'tests/ceftests/test_server_runner_normal.cc',
+      'tests/ceftests/test_server_runner_test.cc',
       'tests/ceftests/test_server_unittest.cc',
       'tests/ceftests/test_suite.cc',
       'tests/ceftests/test_suite.h',
       'tests/ceftests/test_util.cc',
       'tests/ceftests/test_util.h',
+      'tests/ceftests/time_unittest.cc',
       'tests/ceftests/thread_helper.cc',
       'tests/ceftests/thread_helper.h',
       'tests/ceftests/thread_unittest.cc',
@@ -537,34 +585,51 @@
       'tests/ceftests/zip_reader_unittest.cc',
     ],
     'ceftests_sources_win': [
+      'tests/ceftests/resource_util_win_dir.cc',
       'tests/ceftests/resource_util_win_idmap.cc',
-      'tests/ceftests/resources/win/ceftests.rc',
     ],
     'ceftests_sources_resources_win': [
-      'tests/ceftests/resources/win/ceftests.exe.manifest',
-      'tests/ceftests/resources/win/ceftests.ico',
-      'tests/ceftests/resources/win/small.ico',
+      'tests/ceftests/win/ceftests.exe.manifest',
+      'tests/ceftests/win/ceftests.ico',
+      'tests/ceftests/win/small.ico',
+    ],
+    'ceftests_sources_resources_win_rc': [
+      'tests/ceftests/win/ceftests.rc',
     ],
     'ceftests_sources_mac': [
       'tests/ceftests/os_rendering_unittest_mac.h',
       'tests/ceftests/os_rendering_unittest_mac.mm',
       'tests/ceftests/run_all_unittests_mac.mm',
     ],
-    'ceftests_sources_mac_helper': [
+    'ceftests_sources_mac_browser_shared': [
+      'tests/shared/renderer/client_app_renderer.h',
+    ],
+    'ceftests_sources_mac_helper_shared': [
+      'tests/shared/browser/client_app_browser.h',
       'tests/shared/browser/file_util.cc',
       'tests/shared/browser/file_util.h',
       'tests/shared/browser/resource_util.h',
       'tests/shared/browser/resource_util_mac.mm',
       'tests/shared/browser/resource_util_posix.cc',
+    ],
+    'ceftests_sources_mac_helper': [
       'tests/ceftests/audio_output_unittest.cc',
       'tests/ceftests/client_app_delegates.cc',
       'tests/ceftests/cookie_unittest.cc',
       'tests/ceftests/cors_unittest.cc',
       'tests/ceftests/dom_unittest.cc',
       'tests/ceftests/frame_unittest.cc',
-      'tests/ceftests/message_router_unittest.cc',
+      'tests/ceftests/media_access_unittest.cc',
+      'tests/ceftests/message_router_binary_unittest.cc',
+      'tests/ceftests/message_router_harness_unittest.cc',
+      'tests/ceftests/message_router_multi_query_unittest.cc',
+      'tests/ceftests/message_router_single_query_unittest.cc',
+      'tests/ceftests/message_router_threshold_unittest.cc',
+      'tests/ceftests/message_router_unittest_utils.cc',
+      'tests/ceftests/message_router_unittest_utils.h',
       'tests/ceftests/navigation_unittest.cc',
       'tests/ceftests/pdf_viewer_unittest.cc',
+      'tests/ceftests/permission_prompt_unittest.cc',
       'tests/ceftests/preference_unittest.cc',
       'tests/ceftests/process_message_unittest.cc',
       'tests/ceftests/request_handler_unittest.cc',
@@ -574,6 +639,8 @@
       'tests/ceftests/routing_test_handler.cc',
       'tests/ceftests/routing_test_handler.h',
       'tests/ceftests/scheme_handler_unittest.cc',
+      'tests/ceftests/send_shared_process_message_unittest.cc',
+      "tests/ceftests/shared_process_message_unittest.cc",
       'tests/ceftests/urlrequest_unittest.cc',
       'tests/ceftests/test_handler.cc',
       'tests/ceftests/test_handler.h',
@@ -581,6 +648,14 @@
       'tests/ceftests/test_request.h',
       'tests/ceftests/test_server.cc',
       'tests/ceftests/test_server.h',
+      'tests/ceftests/test_server_observer.h',
+      'tests/ceftests/test_server_observer.cc',
+      'tests/ceftests/test_server_manager.h',
+      'tests/ceftests/test_server_manager.cc',
+      'tests/ceftests/test_server_runner.h',
+      'tests/ceftests/test_server_runner.cc',
+      'tests/ceftests/test_server_runner_normal.cc',
+      'tests/ceftests/test_server_runner_test.cc',
       'tests/ceftests/test_suite.cc',
       'tests/ceftests/test_suite.h',
       'tests/ceftests/test_util.cc',
@@ -593,10 +668,10 @@
       'tests/ceftests/v8_unittest.cc',
     ],
     'ceftests_bundle_resources_mac': [
-      'tests/ceftests/resources/mac/ceftests.icns',
-      'tests/ceftests/resources/mac/English.lproj/InfoPlist.strings',
-      'tests/ceftests/resources/mac/English.lproj/MainMenu.xib',
-      'tests/ceftests/resources/mac/Info.plist',
+      'tests/ceftests/mac/ceftests.icns',
+      'tests/ceftests/mac/English.lproj/InfoPlist.strings',
+      'tests/ceftests/mac/English.lproj/MainMenu.xib',
+      'tests/ceftests/mac/Info.plist.in',
     ],
     'ceftests_sources_linux': [
       'tests/ceftests/resource_util_linux.cc',

cmake/cef_macros.cmake.in

@@ -95,43 +95,64 @@ macro(SET_CEF_TARGET_OUT_DIR)
   endif()
 endmacro()
 
-# Copy a list of files from one directory to another. Relative files paths are maintained.
-# The path component of the source |file_list| will be removed.
+# Copy a list of files from one directory to another. Relative file paths are maintained.
 macro(COPY_FILES target file_list source_dir target_dir)
   foreach(FILENAME ${file_list})
     set(source_file ${source_dir}/${FILENAME})
+
+    # Remove the target file path component.
     get_filename_component(target_name ${FILENAME} NAME)
     set(target_file ${target_dir}/${target_name})
 
-    string(FIND ${source_file} "$<CONFIGURATION>" _pos)
-    if(NOT ${_pos} EQUAL -1)
-      # Must test with an actual configuration directory.
-      string(REPLACE "$<CONFIGURATION>" "Release" existing_source_file ${source_file})
-      if(NOT EXISTS ${existing_source_file})
-        string(REPLACE "$<CONFIGURATION>" "Debug" existing_source_file ${source_file})
-      endif()
-    else()
-      set(existing_source_file ${source_file})
-    endif()
-
-    if(IS_DIRECTORY ${existing_source_file})
-      add_custom_command(
-        TARGET ${target}
-        POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_directory "${source_file}" "${target_file}"
-        VERBATIM
-        )
-    else()
-      add_custom_command(
-        TARGET ${target}
-        POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different "${source_file}" "${target_file}"
-        VERBATIM
-        )
-    endif()
+    COPY_SINGLE_FILE(${target} ${source_file} ${target_file})
   endforeach()
 endmacro()
 
+# Copy a list of files from one directory to another. Relative file paths are maintained.
+macro(COPY_RESOURCES target file_list prefix_list source_dir target_dir)
+  foreach(FILENAME ${file_list})
+    set(source_file ${source_dir}/${FILENAME})
+
+    # Remove one or more prefixes from the source paths.
+    set(TARGET_FILENAME "${FILENAME}")
+    foreach(PREFIX ${prefix_list})
+      string(REGEX REPLACE "^.*${PREFIX}" "" TARGET_FILENAME ${TARGET_FILENAME})
+    endforeach()
+    set(target_file ${target_dir}/${TARGET_FILENAME})
+
+    COPY_SINGLE_FILE(${target} ${source_file} ${target_file})
+  endforeach()
+endmacro()
+
+macro(COPY_SINGLE_FILE target source_file target_file)
+  string(FIND ${source_file} "$<CONFIGURATION>" _pos)
+  if(NOT ${_pos} EQUAL -1)
+    # Must test with an actual configuration directory.
+    string(REPLACE "$<CONFIGURATION>" "Release" existing_source_file ${source_file})
+    if(NOT EXISTS ${existing_source_file})
+      string(REPLACE "$<CONFIGURATION>" "Debug" existing_source_file ${source_file})
+    endif()
+  else()
+    set(existing_source_file ${source_file})
+  endif()
+
+  if(IS_DIRECTORY ${existing_source_file})
+    add_custom_command(
+      TARGET ${target}
+      POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy_directory "${source_file}" "${target_file}"
+      VERBATIM
+      )
+  else()
+    add_custom_command(
+      TARGET ${target}
+      POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${source_file}" "${target_file}"
+      VERBATIM
+      )
+  endif()
+endmacro()
+
 
 #
 # Linux macros.

cmake/cef_variables.cmake.in

@@ -26,18 +26,14 @@ endif()
 
 # Determine the project architecture.
 if(NOT DEFINED PROJECT_ARCH)
-  if(OS_WINDOWS AND "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "arm64")
+  if(("${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "arm64") OR
+     ("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM64"))
     set(PROJECT_ARCH "arm64")
   elseif(CMAKE_SIZEOF_VOID_P MATCHES 8)
     set(PROJECT_ARCH "x86_64")
   else()
     set(PROJECT_ARCH "x86")
   endif()
-
-  if(OS_MAC)
-    # PROJECT_ARCH should be specified on Mac OS X.
-    message(WARNING "No PROJECT_ARCH value specified, using ${PROJECT_ARCH}")
-  endif()
 endif()
 
 if(${CMAKE_GENERATOR} STREQUAL "Ninja")
@@ -63,7 +59,7 @@ set(CEF_LIBCEF_DLL_WRAPPER_PATH "${_CEF_ROOT}/libcef_dll")
 
 # Shared compiler/linker flags.
 list(APPEND CEF_COMPILER_DEFINES
-  # Allow C++ programs to use stdint.h macros specified in the C99 standard that aren't 
+  # Allow C++ programs to use stdint.h macros specified in the C99 standard that aren't
   # in the C++ standard (e.g. UINT8_MAX, INT64_MIN, etc)
   __STDC_CONSTANT_MACROS __STDC_FORMAT_MACROS
   )
@@ -105,7 +101,7 @@ if(OS_LINUX)
     -fno-rtti                       # Disable real-time type information
     -fno-threadsafe-statics         # Don't generate thread-safe statics
     -fvisibility-inlines-hidden     # Give hidden visibility to inlined class member functions
-    -std=c++14                      # Use the C++14 language standard
+    -std=c++17                      # Use the C++17 language standard
     -Wsign-compare                  # Warn about mixed signed/unsigned type comparisons
     )
   list(APPEND CEF_COMPILER_FLAGS_DEBUG
@@ -227,7 +223,6 @@ if(OS_LINUX)
     snapshot_blob.bin
     v8_context_snapshot.bin
     vk_swiftshader_icd.json
-    swiftshader
     )
 
   # List of CEF resource files.
@@ -277,7 +272,7 @@ if(OS_MAC)
     -fno-threadsafe-statics         # Don't generate thread-safe statics
     -fobjc-call-cxx-cdtors          # Call the constructor/destructor of C++ instance variables in ObjC objects
     -fvisibility-inlines-hidden     # Give hidden visibility to inlined class member functions
-    -std=c++14                      # Use the C++14 language standard
+    -std=c++17                      # Use the C++17 language standard
     -Wno-narrowing                  # Don't warn about type narrowing
     -Wsign-compare                  # Warn about mixed signed/unsigned type comparisons
     )
@@ -309,13 +304,14 @@ if(OS_MAC)
   # Standard libraries.
   set(CEF_STANDARD_LIBS
     -lpthread
-    "-framework Cocoa"
     "-framework AppKit"
+    "-framework Cocoa"
+    "-framework IOSurface"
     )
 
   # Find the newest available base SDK.
   execute_process(COMMAND xcode-select --print-path OUTPUT_VARIABLE XCODE_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
-  foreach(OS_VERSION 10.15 10.14 10.13 10.12 10.11)
+  foreach(OS_VERSION 14.2 14.0 11.0)
     set(SDK "${XCODE_PATH}/Platforms/MacOSX.platform/Developer/SDKs/MacOSX${OS_VERSION}.sdk")
     if(NOT "${CMAKE_OSX_SYSROOT}" AND EXISTS "${SDK}" AND IS_DIRECTORY "${SDK}")
       set(CMAKE_OSX_SYSROOT ${SDK})
@@ -323,7 +319,7 @@ if(OS_MAC)
   endforeach()
 
   # Target SDK.
-  set(CEF_TARGET_SDK               "10.11")
+  set(CEF_TARGET_SDK               "11.0")
   list(APPEND CEF_COMPILER_FLAGS
     -mmacosx-version-min=${CEF_TARGET_SDK}
   )
@@ -351,6 +347,10 @@ if(OS_MAC)
       CEF_USE_SANDBOX   # Used by apps to test if the sandbox is enabled
       )
 
+    list(APPEND CEF_STANDARD_LIBS
+      -lsandbox
+      )
+
     # CEF sandbox library paths.
     set(CEF_SANDBOX_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/cef_sandbox.a")
     set(CEF_SANDBOX_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/cef_sandbox.a")
@@ -360,6 +360,7 @@ if(OS_MAC)
   # Format is "<name suffix>:<target suffix>:<plist suffix>".
   set(CEF_HELPER_APP_SUFFIXES
     "::"
+    " (Alerts):_alerts:.alerts"
     " (GPU):_gpu:.gpu"
     " (Plugin):_plugin:.plugin"
     " (Renderer):_renderer:.renderer"
@@ -427,17 +428,75 @@ if(OS_WINDOWS)
     /Ob2          # Inline any suitable function
     /GF           # Enable string pooling
     )
+  list(APPEND CEF_CXX_COMPILER_FLAGS
+    /std:c++17    # Use the C++17 language standard
+    )
   list(APPEND CEF_LINKER_FLAGS_DEBUG
     /DEBUG        # Generate debug information
     )
   list(APPEND CEF_EXE_LINKER_FLAGS
     /MANIFEST:NO        # No default manifest (see ADD_WINDOWS_MANIFEST macro usage)
     /LARGEADDRESSAWARE  # Allow 32-bit processes to access 3GB of RAM
+
+    # Delayload most libraries as the dlls are simply not required at startup (or
+    # at all, depending on the process type). Some dlls open handles when they are
+    # loaded, and we may not want them to be loaded in renderers or other sandboxed
+    # processes. Conversely, some dlls must be loaded before sandbox lockdown. In
+    # unsandboxed processes they will load when first needed. The linker will
+    # automatically ignore anything which is not linked to the binary at all (it is
+    # harmless to have an unmatched /delayload). This list should be kept in sync
+    # with Chromium's "delayloads" target from the //build/config/win/BUILD.gn file.
+    /DELAYLOAD:api-ms-win-core-winrt-error-l1-1-0.dll
+    /DELAYLOAD:api-ms-win-core-winrt-l1-1-0.dll
+    /DELAYLOAD:api-ms-win-core-winrt-string-l1-1-0.dll
+    /DELAYLOAD:advapi32.dll
+    /DELAYLOAD:comctl32.dll
+    /DELAYLOAD:comdlg32.dll
+    /DELAYLOAD:credui.dll
+    /DELAYLOAD:cryptui.dll
+    /DELAYLOAD:d3d11.dll
+    /DELAYLOAD:d3d9.dll
+    /DELAYLOAD:dwmapi.dll
+    /DELAYLOAD:dxgi.dll
+    /DELAYLOAD:dxva2.dll
+    /DELAYLOAD:esent.dll
+    /DELAYLOAD:gdi32.dll
+    /DELAYLOAD:hid.dll
+    /DELAYLOAD:imagehlp.dll
+    /DELAYLOAD:imm32.dll
+    /DELAYLOAD:msi.dll
+    /DELAYLOAD:netapi32.dll
+    /DELAYLOAD:ncrypt.dll
+    /DELAYLOAD:ole32.dll
+    /DELAYLOAD:oleacc.dll
+    /DELAYLOAD:propsys.dll
+    /DELAYLOAD:psapi.dll
+    /DELAYLOAD:rpcrt4.dll
+    /DELAYLOAD:rstrtmgr.dll
+    /DELAYLOAD:setupapi.dll
+    /DELAYLOAD:shell32.dll
+    /DELAYLOAD:shlwapi.dll
+    /DELAYLOAD:uiautomationcore.dll
+    /DELAYLOAD:urlmon.dll
+    /DELAYLOAD:user32.dll
+    /DELAYLOAD:usp10.dll
+    /DELAYLOAD:uxtheme.dll
+    /DELAYLOAD:wer.dll
+    /DELAYLOAD:wevtapi.dll
+    /DELAYLOAD:wininet.dll
+    /DELAYLOAD:winusb.dll
+    /DELAYLOAD:wsock32.dll
+    /DELAYLOAD:wtsapi32.dll
     )
   list(APPEND CEF_COMPILER_DEFINES
     WIN32 _WIN32 _WINDOWS             # Windows platform
     UNICODE _UNICODE                  # Unicode build
-    WINVER=0x0601 _WIN32_WINNT=0x601  # Targeting Windows 7
+    # Targeting Windows 10. We can't say `=_WIN32_WINNT_WIN10` here because
+    # some files do `#if WINVER < 0x0600` without including windows.h before,
+    # and then _WIN32_WINNT_WIN10 isn't yet known to be 0x0A00.
+    WINVER=0x0A00
+    _WIN32_WINNT=0x0A00
+    NTDDI_VERSION=NTDDI_WIN10_FE
     NOMINMAX                          # Use the standard's templated min/max
     WIN32_LEAN_AND_MEAN               # Exclude less common API declarations
     _HAS_EXCEPTIONS=0                 # Disable exceptions
@@ -446,6 +505,23 @@ if(OS_WINDOWS)
     NDEBUG _NDEBUG                    # Not a debug build
     )
 
+  if(PROJECT_ARCH STREQUAL "x86")
+    # Set the initial stack size to 0.5MiB, instead of the 1.5MiB minimum
+    # needed by CEF'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. The main thread (in 32-bit builds
+    # only) uses fibers to switch to a 4MiB stack at runtime via
+    # CefRunWinMainWithPreferredStackSize().
+    list(APPEND CEF_EXE_LINKER_FLAGS
+      /STACK:0x80000
+      )
+  else()
+    # Increase the initial stack size to 8MiB from the default 1MiB.
+    list(APPEND CEF_EXE_LINKER_FLAGS
+      /STACK:0x800000
+      )
+  endif()
+
   # Standard libraries.
   set(CEF_STANDARD_LIBS
     comctl32.lib
@@ -468,6 +544,7 @@ if(OS_WINDOWS)
   # List of CEF binary files.
   set(CEF_BINARY_FILES
     chrome_elf.dll
+    d3dcompiler_47.dll
     libcef.dll
     libEGL.dll
     libGLESv2.dll
@@ -476,12 +553,12 @@ if(OS_WINDOWS)
     vk_swiftshader.dll
     vk_swiftshader_icd.json
     vulkan-1.dll
-    swiftshader
     )
 
-  if(NOT PROJECT_ARCH STREQUAL "arm64")
+  if(PROJECT_ARCH STREQUAL "x86_64")
     list(APPEND CEF_BINARY_FILES
-      d3dcompiler_47.dll
+      dxil.dll
+      dxcompiler.dll
       )
   endif()
 
@@ -508,14 +585,18 @@ if(OS_WINDOWS)
       Advapi32.lib
       dbghelp.lib
       Delayimp.lib
+      ntdll.lib
       OleAut32.lib
       PowrProf.lib
       Propsys.lib
       psapi.lib
       SetupAPI.lib
       Shell32.lib
+      Shcore.lib
+      Userenv.lib
       version.lib
       wbemuuid.lib
+      WindowsApp.lib
       winmm.lib
       )
 

include/base/cef_atomic_flag.h

@@ -49,9 +49,11 @@
 
 namespace base {
 
-// A flag that can safely be set from one thread and read from other threads.
-//
-// This class IS NOT intended for synchronization between threads.
+///
+/// A flag that can safely be set from one thread and read from other threads.
+///
+/// This class IS NOT intended for synchronization between threads.
+///
 class AtomicFlag {
  public:
   AtomicFlag();
@@ -61,19 +63,26 @@ class AtomicFlag {
 
   ~AtomicFlag();
 
-  // Set the flag. Must always be called from the same thread.
+  ///
+  /// Set the flag. Must always be called from the same thread.
+  ///
   void Set();
 
-  // Returns true iff the flag was set. If this returns true, the current thread
-  // is guaranteed to be synchronized with all memory operations on the thread
-  // which invoked Set() up until at least the first call to Set() on it.
+  ///
+  /// Returns true iff the flag was set. If this returns true, the current
+  /// thread is guaranteed to be synchronized with all memory operations on the
+  /// thread which invoked Set() up until at least the first call to Set() on
+  /// it.
+  ///
   bool IsSet() const {
     // Inline here: this has a measurable performance impact on base::WeakPtr.
     return flag_.load(std::memory_order_acquire) != 0;
   }
 
-  // Resets the flag. Be careful when using this: callers might not expect
-  // IsSet() to return false after returning true once.
+  ///
+  /// Resets the flag. Be careful when using this: callers might not expect
+  /// IsSet() to return false after returning true once.
+  ///
   void UnsafeResetForTesting();
 
  private:

include/base/cef_atomic_ref_count.h

@@ -58,19 +58,25 @@ class AtomicRefCount {
   explicit constexpr AtomicRefCount(int initial_value)
       : ref_count_(initial_value) {}
 
-  // Increment a reference count.
-  // Returns the previous value of the count.
+  ///
+  /// Increment a reference count.
+  /// Returns the previous value of the count.
+  ///
   int Increment() { return Increment(1); }
 
-  // Increment a reference count by "increment", which must exceed 0.
-  // Returns the previous value of the count.
+  ///
+  /// Increment a reference count by "increment", which must exceed 0.
+  /// Returns the previous value of the count.
+  ///
   int Increment(int increment) {
     return ref_count_.fetch_add(increment, std::memory_order_relaxed);
   }
 
-  // Decrement a reference count, and return whether the result is non-zero.
-  // Insert barriers to ensure that state written before the reference count
-  // became zero will be visible to a thread that has just made the count zero.
+  ///
+  /// Decrement a reference count, and return whether the result is non-zero.
+  /// Insert barriers to ensure that state written before the reference count
+  /// became zero will be visible to a thread that has just made the count zero.
+  ///
   bool Decrement() {
     // TODO(jbroman): Technically this doesn't need to be an acquire operation
     // unless the result is 1 (i.e., the ref count did indeed reach zero).
@@ -79,23 +85,29 @@ class AtomicRefCount {
     return ref_count_.fetch_sub(1, std::memory_order_acq_rel) != 1;
   }
 
-  // Return whether the reference count is one.  If the reference count is used
-  // in the conventional way, a refrerence count of 1 implies that the current
-  // thread owns the reference and no other thread shares it.  This call
-  // performs the test for a reference count of one, and performs the memory
-  // barrier needed for the owning thread to act on the object, knowing that it
-  // has exclusive access to the object.
+  ///
+  /// Return whether the reference count is one.  If the reference count is used
+  /// in the conventional way, a refrerence count of 1 implies that the current
+  /// thread owns the reference and no other thread shares it.  This call
+  /// performs the test for a reference count of one, and performs the memory
+  /// barrier needed for the owning thread to act on the object, knowing that it
+  /// has exclusive access to the object.
+  ///
   bool IsOne() const { return ref_count_.load(std::memory_order_acquire) == 1; }
 
-  // Return whether the reference count is zero.  With conventional object
-  // referencing counting, the object will be destroyed, so the reference count
-  // should never be zero.  Hence this is generally used for a debug check.
+  ///
+  /// Return whether the reference count is zero.  With conventional object
+  /// referencing counting, the object will be destroyed, so the reference count
+  /// should never be zero.  Hence this is generally used for a debug check.
+  ///
   bool IsZero() const {
     return ref_count_.load(std::memory_order_acquire) == 0;
   }
 
-  // Returns the current reference count (with no barriers). This is subtle, and
-  // should be used only for debugging.
+  ///
+  /// Returns the current reference count (with no barriers). This is subtle,
+  /// and should be used only for debugging.
+  ///
   int SubtleRefCountForDebug() const {
     return ref_count_.load(std::memory_order_relaxed);
   }

include/base/cef_auto_reset.h

@@ -73,8 +73,9 @@ class AutoReset {
   }
 
   ~AutoReset() {
-    if (scoped_variable_)
+    if (scoped_variable_) {
       *scoped_variable_ = std::move(original_value_);
+    }
   }
 
  private:

include/base/cef_bind.h

@@ -28,41 +28,42 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// base::BindOnce() and base::BindRepeating() are helpers for creating
-// base::OnceCallback and base::RepeatingCallback objects respectively.
-//
-// For a runnable object of n-arity, the base::Bind*() family allows partial
-// application of the first m arguments. The remaining n - m arguments must be
-// passed when invoking the callback with Run().
-//
-//   // The first argument is bound at callback creation; the remaining
-//   // two must be passed when calling Run() on the callback object.
-//   base::OnceCallback<long(int, long)> cb = base::BindOnce(
-//       [](short x, int y, long z) { return x * y * z; }, 42);
-//
-// When binding to a method, the receiver object must also be specified at
-// callback creation time. When Run() is invoked, the method will be invoked on
-// the specified receiver object.
-//
-//   class C : public base::RefCounted<C> { void F(); };
-//   auto instance = base::MakeRefCounted<C>();
-//   auto cb = base::BindOnce(&C::F, instance);
-//   std::move(cb).Run();  // Identical to instance->F()
-//
-// See //docs/callback.md for the full documentation.
-//
-// -----------------------------------------------------------------------------
+///
+/// \file
+/// base::BindOnce() and base::BindRepeating() are helpers for creating
+/// base::OnceCallback and base::RepeatingCallback objects respectively.
+///
+/// For a runnable object of n-arity, the base::Bind*() family allows partial
+/// application of the first m arguments. The remaining n - m arguments must be
+/// passed when invoking the callback with Run().
+///
+/// <pre>
+///   // The first argument is bound at callback creation; the remaining
+///   // two must be passed when calling Run() on the callback object.
+///   base::OnceCallback<long(int, long)> cb = base::BindOnce(
+///       [](short x, int y, long z) { return x * y * z; }, 42);
+/// </pre>
+///
+/// When binding to a method, the receiver object must also be specified at
+/// callback creation time. When Run() is invoked, the method will be invoked on
+/// the specified receiver object.
+///
+/// <pre>
+///   class C : public base::RefCounted<C> { void F(); };
+///   auto instance = base::MakeRefCounted<C>();
+///   auto cb = base::BindOnce(&C::F, instance);
+///   std::move(cb).Run();  // Identical to instance->F()
+/// </pre>
+///
+/// See https://chromium.googlesource.com/chromium/src/+/lkgr/docs/callback.md
+/// for the full documentation.
+///
+
 // Implementation notes
-// -----------------------------------------------------------------------------
 //
 // If you're reading the implementation, before proceeding further, you should
-// read the top comment of base/internal/cef_bind_internal.h for a definition of
-// common terms and concepts.
+// read the top comment of base/internal/cef_bind_internal.h for a definition
+// of common terms and concepts.
 
 #ifndef CEF_INCLUDE_BASE_CEF_BIND_H_
 #define CEF_INCLUDE_BASE_CEF_BIND_H_
@@ -70,7 +71,7 @@
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/bind.h"
+#include "base/functional/bind.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
@@ -83,7 +84,6 @@
 
 #include "include/base/cef_build.h"
 #include "include/base/cef_compiler_specific.h"
-#include "include/base/cef_template_util.h"
 #include "include/base/internal/cef_bind_internal.h"
 
 #if defined(OS_APPLE) && !HAS_FEATURE(objc_arc)
@@ -92,40 +92,45 @@
 
 namespace base {
 
-// Bind as OnceCallback.
+///
+/// Bind as OnceCallback.
+///
 template <typename Functor, typename... Args>
-inline OnceCallback<internal::MakeUnboundRunType<Functor, Args...>> BindOnce(
-    Functor&& functor,
-    Args&&... args) {
-  static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
+inline OnceCallback<cef_internal::MakeUnboundRunType<Functor, Args...>>
+BindOnce(Functor&& functor, Args&&... args) {
+  static_assert(!cef_internal::IsOnceCallback<std::decay_t<Functor>>() ||
                     (std::is_rvalue_reference<Functor&&>() &&
                      !std::is_const<std::remove_reference_t<Functor>>()),
                 "BindOnce requires non-const rvalue for OnceCallback binding."
                 " I.e.: base::BindOnce(std::move(callback)).");
   static_assert(
-      conjunction<
-          internal::AssertBindArgIsNotBasePassed<std::decay_t<Args>>...>::value,
+      std::conjunction<cef_internal::AssertBindArgIsNotBasePassed<
+          std::decay_t<Args>>...>::value,
       "Use std::move() instead of base::Passed() with base::BindOnce()");
 
-  return internal::BindImpl<OnceCallback>(std::forward<Functor>(functor),
-                                          std::forward<Args>(args)...);
+  return cef_internal::BindImpl<OnceCallback>(std::forward<Functor>(functor),
+                                              std::forward<Args>(args)...);
 }
 
-// Bind as RepeatingCallback.
+///
+/// Bind as RepeatingCallback.
+///
 template <typename Functor, typename... Args>
-inline RepeatingCallback<internal::MakeUnboundRunType<Functor, Args...>>
+inline RepeatingCallback<cef_internal::MakeUnboundRunType<Functor, Args...>>
 BindRepeating(Functor&& functor, Args&&... args) {
   static_assert(
-      !internal::IsOnceCallback<std::decay_t<Functor>>(),
+      !cef_internal::IsOnceCallback<std::decay_t<Functor>>(),
       "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
 
-  return internal::BindImpl<RepeatingCallback>(std::forward<Functor>(functor),
-                                               std::forward<Args>(args)...);
+  return cef_internal::BindImpl<RepeatingCallback>(
+      std::forward<Functor>(functor), std::forward<Args>(args)...);
 }
 
-// Special cases for binding to a base::Callback without extra bound arguments.
-// We CHECK() the validity of callback to guard against null pointers
-// accidentally ending up in posted tasks, causing hard-to-debug crashes.
+///
+/// Special cases for binding to a base::Callback without extra bound arguments.
+/// We CHECK() the validity of callback to guard against null pointers
+/// accidentally ending up in posted tasks, causing hard-to-debug crashes.
+///
 template <typename Signature>
 OnceCallback<Signature> BindOnce(OnceCallback<Signature> callback) {
   CHECK(callback);
@@ -145,198 +150,231 @@ RepeatingCallback<Signature> BindRepeating(
   return callback;
 }
 
-// Unretained() allows binding a non-refcounted class, and to disable
-// refcounting on arguments that are refcounted objects.
-//
-// EXAMPLE OF Unretained():
-//
-//   class Foo {
-//    public:
-//     void func() { cout << "Foo:f" << endl; }
-//   };
-//
-//   // In some function somewhere.
-//   Foo foo;
-//   OnceClosure foo_callback =
-//       BindOnce(&Foo::func, Unretained(&foo));
-//   std::move(foo_callback).Run();  // Prints "Foo:f".
-//
-// Without the Unretained() wrapper on |&foo|, the above call would fail
-// to compile because Foo does not support the AddRef() and Release() methods.
+///
+/// Unretained() allows binding a non-refcounted class, and to disable
+/// refcounting on arguments that are refcounted objects.
+///
+/// EXAMPLE OF Unretained():
+///
+/// <pre>
+///   class Foo {
+///    public:
+///     void func() { cout << "Foo:f" << endl; }
+///   };
+///
+///   // In some function somewhere.
+///   Foo foo;
+///   OnceClosure foo_callback =
+///       BindOnce(&Foo::func, Unretained(&foo));
+///   std::move(foo_callback).Run();  // Prints "Foo:f".
+/// </pre>
+///
+/// Without the Unretained() wrapper on |&foo|, the above call would fail
+/// to compile because Foo does not support the AddRef() and Release() methods.
+///
 template <typename T>
-inline internal::UnretainedWrapper<T> Unretained(T* o) {
-  return internal::UnretainedWrapper<T>(o);
+inline cef_internal::UnretainedWrapper<T> Unretained(T* o) {
+  return cef_internal::UnretainedWrapper<T>(o);
 }
 
-// RetainedRef() accepts a ref counted object and retains a reference to it.
-// When the callback is called, the object is passed as a raw pointer.
-//
-// EXAMPLE OF RetainedRef():
-//
-//    void foo(RefCountedBytes* bytes) {}
-//
-//    scoped_refptr<RefCountedBytes> bytes = ...;
-//    OnceClosure callback = BindOnce(&foo, base::RetainedRef(bytes));
-//    std::move(callback).Run();
-//
-// Without RetainedRef, the scoped_refptr would try to implicitly convert to
-// a raw pointer and fail compilation:
-//
-//    OnceClosure callback = BindOnce(&foo, bytes); // ERROR!
+///
+/// RetainedRef() accepts a ref counted object and retains a reference to it.
+/// When the callback is called, the object is passed as a raw pointer.
+///
+/// EXAMPLE OF RetainedRef():
+///
+/// <pre>
+///    void foo(RefCountedBytes* bytes) {}
+///
+///    scoped_refptr<RefCountedBytes> bytes = ...;
+///    OnceClosure callback = BindOnce(&foo, base::RetainedRef(bytes));
+///    std::move(callback).Run();
+/// </pre>
+///
+/// Without RetainedRef, the scoped_refptr would try to implicitly convert to
+/// a raw pointer and fail compilation:
+///
+/// <pre>
+///    OnceClosure callback = BindOnce(&foo, bytes); // ERROR!
+/// </pre>
+///
 template <typename T>
-inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
-  return internal::RetainedRefWrapper<T>(o);
+inline cef_internal::RetainedRefWrapper<T> RetainedRef(T* o) {
+  return cef_internal::RetainedRefWrapper<T>(o);
 }
 template <typename T>
-inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
-  return internal::RetainedRefWrapper<T>(std::move(o));
+inline cef_internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
+  return cef_internal::RetainedRefWrapper<T>(std::move(o));
 }
 
-// Owned() transfers ownership of an object to the callback resulting from
-// bind; the object will be deleted when the callback is deleted.
-//
-// EXAMPLE OF Owned():
-//
-//   void foo(int* arg) { cout << *arg << endl }
-//
-//   int* pn = new int(1);
-//   RepeatingClosure foo_callback = BindRepeating(&foo, Owned(pn));
-//
-//   foo_callback.Run();  // Prints "1"
-//   foo_callback.Run();  // Prints "1"
-//   *pn = 2;
-//   foo_callback.Run();  // Prints "2"
-//
-//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
-//                          // |foo_callback| goes out of scope.
-//
-// Without Owned(), someone would have to know to delete |pn| when the last
-// reference to the callback is deleted.
+///
+/// Owned() transfers ownership of an object to the callback resulting from
+/// bind; the object will be deleted when the callback is deleted.
+///
+/// EXAMPLE OF Owned():
+///
+/// <pre>
+///   void foo(int* arg) { cout << *arg << endl }
+///
+///   int* pn = new int(1);
+///   RepeatingClosure foo_callback = BindRepeating(&foo, Owned(pn));
+///
+///   foo_callback.Run();  // Prints "1"
+///   foo_callback.Run();  // Prints "1"
+///   *pn = 2;
+///   foo_callback.Run();  // Prints "2"
+///
+///   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
+///                          // |foo_callback| goes out of scope.
+/// </pre>
+///
+/// Without Owned(), someone would have to know to delete |pn| when the last
+/// reference to the callback is deleted.
+///
 template <typename T>
-inline internal::OwnedWrapper<T> Owned(T* o) {
-  return internal::OwnedWrapper<T>(o);
+inline cef_internal::OwnedWrapper<T> Owned(T* o) {
+  return cef_internal::OwnedWrapper<T>(o);
 }
 
 template <typename T, typename Deleter>
-inline internal::OwnedWrapper<T, Deleter> Owned(
+inline cef_internal::OwnedWrapper<T, Deleter> Owned(
     std::unique_ptr<T, Deleter>&& ptr) {
-  return internal::OwnedWrapper<T, Deleter>(std::move(ptr));
+  return cef_internal::OwnedWrapper<T, Deleter>(std::move(ptr));
 }
 
-// OwnedRef() stores an object in the callback resulting from
-// bind and passes a reference to the object to the bound function.
-//
-// EXAMPLE OF OwnedRef():
-//
-//   void foo(int& arg) { cout << ++arg << endl }
-//
-//   int counter = 0;
-//   RepeatingClosure foo_callback = BindRepeating(&foo, OwnedRef(counter));
-//
-//   foo_callback.Run();  // Prints "1"
-//   foo_callback.Run();  // Prints "2"
-//   foo_callback.Run();  // Prints "3"
-//
-//   cout << counter;     // Prints "0", OwnedRef creates a copy of counter.
-//
-//  Supports OnceCallbacks as well, useful to pass placeholder arguments:
-//
-//   void bar(int& ignore, const std::string& s) { cout << s << endl }
-//
-//   OnceClosure bar_callback = BindOnce(&bar, OwnedRef(0), "Hello");
-//
-//   std::move(bar_callback).Run(); // Prints "Hello"
-//
-// Without OwnedRef() it would not be possible to pass a mutable reference to an
-// object owned by the callback.
+///
+/// OwnedRef() stores an object in the callback resulting from
+/// bind and passes a reference to the object to the bound function.
+///
+/// EXAMPLE OF OwnedRef():
+///
+/// <pre>
+///   void foo(int& arg) { cout << ++arg << endl }
+///
+///   int counter = 0;
+///   RepeatingClosure foo_callback = BindRepeating(&foo, OwnedRef(counter));
+///
+///   foo_callback.Run();  // Prints "1"
+///   foo_callback.Run();  // Prints "2"
+///   foo_callback.Run();  // Prints "3"
+///
+///   cout << counter;     // Prints "0", OwnedRef creates a copy of counter.
+/// </pre>
+///
+///  Supports OnceCallbacks as well, useful to pass placeholder arguments:
+///
+/// <pre>
+///   void bar(int& ignore, const std::string& s) { cout << s << endl }
+///
+///   OnceClosure bar_callback = BindOnce(&bar, OwnedRef(0), "Hello");
+///
+///   std::move(bar_callback).Run(); // Prints "Hello"
+/// </pre>
+///
+/// Without OwnedRef() it would not be possible to pass a mutable reference to
+/// an object owned by the callback.
+///
 template <typename T>
-internal::OwnedRefWrapper<std::decay_t<T>> OwnedRef(T&& t) {
-  return internal::OwnedRefWrapper<std::decay_t<T>>(std::forward<T>(t));
+cef_internal::OwnedRefWrapper<std::decay_t<T>> OwnedRef(T&& t) {
+  return cef_internal::OwnedRefWrapper<std::decay_t<T>>(std::forward<T>(t));
 }
 
-// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
-// through a RepeatingCallback. Logically, this signifies a destructive transfer
-// of the state of the argument into the target function. Invoking
-// RepeatingCallback::Run() twice on a callback that was created with a Passed()
-// argument will CHECK() because the first invocation would have already
-// transferred ownership to the target function.
-//
-// Note that Passed() is not necessary with BindOnce(), as std::move() does the
-// same thing. Avoid Passed() in favor of std::move() with BindOnce().
-//
-// EXAMPLE OF Passed():
-//
-//   void TakesOwnership(std::unique_ptr<Foo> arg) { }
-//   std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
-//   }
-//
-//   auto f = std::make_unique<Foo>();
-//
-//   // |cb| is given ownership of Foo(). |f| is now NULL.
-//   // You can use std::move(f) in place of &f, but it's more verbose.
-//   RepeatingClosure cb = BindRepeating(&TakesOwnership, Passed(&f));
-//
-//   // Run was never called so |cb| still owns Foo() and deletes
-//   // it on Reset().
-//   cb.Reset();
-//
-//   // |cb| is given a new Foo created by CreateFoo().
-//   cb = BindRepeating(&TakesOwnership, Passed(CreateFoo()));
-//
-//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
-//   // no longer owns Foo() and, if reset, would not delete Foo().
-//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
-//   cb.Run();  // This CHECK()s since Foo() already been used once.
-//
-// We offer 2 syntaxes for calling Passed(). The first takes an rvalue and is
-// best suited for use with the return value of a function or other temporary
-// rvalues. The second takes a pointer to the scoper and is just syntactic sugar
-// to avoid having to write Passed(std::move(scoper)).
-//
-// Both versions of Passed() prevent T from being an lvalue reference. The first
-// via use of enable_if, and the second takes a T* which will not bind to T&.
+///
+/// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
+/// through a RepeatingCallback. Logically, this signifies a destructive
+/// transfer of the state of the argument into the target function. Invoking
+/// RepeatingCallback::Run() twice on a callback that was created with a
+/// Passed() argument will CHECK() because the first invocation would have
+/// already transferred ownership to the target function.
+///
+/// Note that Passed() is not necessary with BindOnce(), as std::move() does the
+/// same thing. Avoid Passed() in favor of std::move() with BindOnce().
+///
+/// EXAMPLE OF Passed():
+///
+/// <pre>
+///   void TakesOwnership(std::unique_ptr<Foo> arg) { }
+///   std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
+///   }
+///
+///   auto f = std::make_unique<Foo>();
+///
+///   // |cb| is given ownership of Foo(). |f| is now NULL.
+///   // You can use std::move(f) in place of &f, but it's more verbose.
+///   RepeatingClosure cb = BindRepeating(&TakesOwnership, Passed(&f));
+///
+///   // Run was never called so |cb| still owns Foo() and deletes
+///   // it on Reset().
+///   cb.Reset();
+///
+///   // |cb| is given a new Foo created by CreateFoo().
+///   cb = BindRepeating(&TakesOwnership, Passed(CreateFoo()));
+///
+///   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
+///   // no longer owns Foo() and, if reset, would not delete Foo().
+///   cb.Run();  // Foo() is now transferred to |arg| and deleted.
+///   cb.Run();  // This CHECK()s since Foo() already been used once.
+/// </pre>
+///
+/// We offer 2 syntaxes for calling Passed(). The first takes an rvalue and is
+/// best suited for use with the return value of a function or other temporary
+/// rvalues. The second takes a pointer to the scoper and is just syntactic
+/// sugar to avoid having to write Passed(std::move(scoper)).
+///
+/// Both versions of Passed() prevent T from being an lvalue reference. The
+/// first via use of enable_if, and the second takes a T* which will not bind to
+/// T&.
+///
 template <typename T,
           std::enable_if_t<!std::is_lvalue_reference<T>::value>* = nullptr>
-inline internal::PassedWrapper<T> Passed(T&& scoper) {
-  return internal::PassedWrapper<T>(std::move(scoper));
+inline cef_internal::PassedWrapper<T> Passed(T&& scoper) {
+  return cef_internal::PassedWrapper<T>(std::move(scoper));
 }
 template <typename T>
-inline internal::PassedWrapper<T> Passed(T* scoper) {
-  return internal::PassedWrapper<T>(std::move(*scoper));
+inline cef_internal::PassedWrapper<T> Passed(T* scoper) {
+  return cef_internal::PassedWrapper<T>(std::move(*scoper));
 }
 
-// IgnoreResult() is used to adapt a function or callback with a return type to
-// one with a void return. This is most useful if you have a function with,
-// say, a pesky ignorable bool return that you want to use with PostTask or
-// something else that expect a callback with a void return.
-//
-// EXAMPLE OF IgnoreResult():
-//
-//   int DoSomething(int arg) { cout << arg << endl; }
-//
-//   // Assign to a callback with a void return type.
-//   OnceCallback<void(int)> cb = BindOnce(IgnoreResult(&DoSomething));
-//   std::move(cb).Run(1);  // Prints "1".
-//
-//   // Prints "2" on |ml|.
-//   ml->PostTask(FROM_HERE, BindOnce(IgnoreResult(&DoSomething), 2);
+///
+/// IgnoreResult() is used to adapt a function or callback with a return type to
+/// one with a void return. This is most useful if you have a function with,
+/// say, a pesky ignorable bool return that you want to use with PostTask or
+/// something else that expect a callback with a void return.
+///
+/// EXAMPLE OF IgnoreResult():
+///
+/// <pre>
+///   int DoSomething(int arg) { cout << arg << endl; }
+///
+///   // Assign to a callback with a void return type.
+///   OnceCallback<void(int)> cb = BindOnce(IgnoreResult(&DoSomething));
+///   std::move(cb).Run(1);  // Prints "1".
+///
+///   // Prints "2" on |ml|.
+///   ml->PostTask(FROM_HERE, BindOnce(IgnoreResult(&DoSomething), 2);
+/// </pre>
+///
 template <typename T>
-inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
-  return internal::IgnoreResultHelper<T>(std::move(data));
+inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
+  return cef_internal::IgnoreResultHelper<T>(std::move(data));
 }
 
 #if defined(OS_APPLE) && !HAS_FEATURE(objc_arc)
 
-// RetainBlock() is used to adapt an Objective-C block when Automated Reference
-// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the
-// BindOnce and BindRepeating already support blocks then.
-//
-// EXAMPLE OF RetainBlock():
-//
-//   // Wrap the block and bind it to a callback.
-//   OnceCallback<void(int)> cb =
-//       BindOnce(RetainBlock(^(int n) { NSLog(@"%d", n); }));
-//   std::move(cb).Run(1);  // Logs "1".
+///
+/// RetainBlock() is used to adapt an Objective-C block when Automated Reference
+/// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the
+/// BindOnce and BindRepeating already support blocks then.
+///
+/// EXAMPLE OF RetainBlock():
+///
+/// <pre>
+///   // Wrap the block and bind it to a callback.
+///   OnceCallback<void(int)> cb =
+///       BindOnce(RetainBlock(^(int n) { NSLog(@"%d", n); }));
+///   std::move(cb).Run(1);  // Logs "1".
+/// </pre>
+///
 template <typename R, typename... Args>
 base::mac::ScopedBlock<R (^)(Args...)> RetainBlock(R (^block)(Args...)) {
   return base::mac::ScopedBlock<R (^)(Args...)>(block,

include/base/cef_build.h

@@ -27,36 +27,40 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// This file adds defines about the platform we're currently building on.
-//
-//  Operating System:
-//    OS_AIX / OS_ANDROID / OS_ASMJS / OS_FREEBSD / OS_FUCHSIA / OS_IOS /
-//    OS_LINUX / OS_MAC / OS_NACL (SFI or NONSFI) / OS_NETBSD / OS_OPENBSD /
-//    OS_QNX / OS_SOLARIS / OS_WIN
-//  Operating System family:
-//    OS_APPLE: IOS or MAC
-//    OS_BSD: FREEBSD or NETBSD or OPENBSD
-//    OS_POSIX: AIX or ANDROID or ASMJS or CHROMEOS or FREEBSD or IOS or LINUX
-//              or MAC or NACL or NETBSD or OPENBSD or QNX or SOLARIS
-//
-//  /!\ Note: OS_CHROMEOS is set by the build system, not this file
-//
-//  Compiler:
-//    COMPILER_MSVC / COMPILER_GCC
-//
-//  Processor:
-//    ARCH_CPU_ARM64 / ARCH_CPU_ARMEL / ARCH_CPU_MIPS / ARCH_CPU_MIPS64 /
-//    ARCH_CPU_MIPS64EL / ARCH_CPU_MIPSEL / ARCH_CPU_PPC64 / ARCH_CPU_S390 /
-//    ARCH_CPU_S390X / ARCH_CPU_X86 / ARCH_CPU_X86_64
-//  Processor family:
-//    ARCH_CPU_ARM_FAMILY: ARMEL or ARM64
-//    ARCH_CPU_MIPS_FAMILY: MIPS64EL or MIPSEL or MIPS64 or MIPS
-//    ARCH_CPU_PPC64_FAMILY: PPC64
-//    ARCH_CPU_S390_FAMILY: S390 or S390X
-//    ARCH_CPU_X86_FAMILY: X86 or X86_64
-//  Processor features:
-//    ARCH_CPU_31_BITS / ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
-//    ARCH_CPU_BIG_ENDIAN / ARCH_CPU_LITTLE_ENDIAN
+/// \file
+/// This file adds defines about the platform we're currently building on.
+///
+/// <pre>
+///  Operating System:
+///    OS_AIX / OS_ANDROID / OS_ASMJS / OS_FREEBSD / OS_FUCHSIA / OS_IOS /
+///    OS_LINUX / OS_MAC / OS_NACL (SFI or NONSFI) / OS_NETBSD / OS_OPENBSD /
+///    OS_QNX / OS_SOLARIS / OS_WIN
+///  Operating System family:
+///    OS_APPLE: IOS or MAC
+///    OS_BSD: FREEBSD or NETBSD or OPENBSD
+///    OS_POSIX: AIX or ANDROID or ASMJS or CHROMEOS or FREEBSD or IOS or LINUX
+///              or MAC or NACL or NETBSD or OPENBSD or QNX or SOLARIS
+///
+///  /!\ Note: OS_CHROMEOS is set by the build system, not this file
+///
+///  Compiler:
+///    COMPILER_MSVC / COMPILER_GCC
+///
+///  Processor:
+///    ARCH_CPU_ARM64 / ARCH_CPU_ARMEL / ARCH_CPU_MIPS / ARCH_CPU_MIPS64 /
+///    ARCH_CPU_MIPS64EL / ARCH_CPU_MIPSEL / ARCH_CPU_PPC64 / ARCH_CPU_S390 /
+///    ARCH_CPU_S390X / ARCH_CPU_X86 / ARCH_CPU_X86_64
+///  Processor family:
+///    ARCH_CPU_ARM_FAMILY: ARMEL or ARM64
+///    ARCH_CPU_MIPS_FAMILY: MIPS64EL or MIPSEL or MIPS64 or MIPS
+///    ARCH_CPU_PPC64_FAMILY: PPC64
+///    ARCH_CPU_S390_FAMILY: S390 or S390X
+///    ARCH_CPU_X86_FAMILY: X86 or X86_64
+///  Processor features:
+///    ARCH_CPU_31_BITS / ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
+///    ARCH_CPU_BIG_ENDIAN / ARCH_CPU_LITTLE_ENDIAN
+/// </pre>
+///
 
 #ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
 #define CEF_INCLUDE_BASE_CEF_BUILD_H_
@@ -65,7 +69,24 @@
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "build/build_config.h"
+#include "cef/libcef/features/features.h"
+
+// The following #defines are used in cef/include/ headers and CEF client-side
+// code. CEF library-side code should use BUILDFLAG checks directly instead of
+// these #defines. CEF client-side code will get these #defines from
+// cef_config.h so any changes must also be reflected in
+// tools/make_config_header.py.
+
+#if BUILDFLAG(IS_LINUX)
+#include "ui/base/ozone_buildflags.h"
+#if BUILDFLAG(IS_OZONE_X11)
+#define CEF_X11 1
+#endif
+#endif
+
 #else  // !USING_CHROMIUM_INCLUDES
+#include "include/cef_config.h"
+
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
@@ -228,19 +249,19 @@
 
 // Type detection for wchar_t.
 #if defined(OS_WIN)
-#define WCHAR_T_IS_UTF16
+#define WCHAR_T_IS_16_BIT
 #elif defined(OS_FUCHSIA)
-#define WCHAR_T_IS_UTF32
+#define WCHAR_T_IS_32_BIT
 #elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
     (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
-#define WCHAR_T_IS_UTF32
+#define WCHAR_T_IS_32_BIT
 #elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
     (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
 // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
 // compile in this mode (in particular, Chrome doesn't). This is intended for
 // other projects using base who manage their own dependencies and make sure
 // short wchar works for them.
-#define WCHAR_T_IS_UTF16
+#define WCHAR_T_IS_16_BIT
 #else
 #error Please add support for your compiler in include/base/cef_build.h
 #endif
@@ -249,7 +270,7 @@
 // The compiler thinks std::string::const_iterator and "const char*" are
 // equivalent types.
 #define STD_STRING_ITERATOR_IS_CHAR_POINTER
-// The compiler thinks std::u16string::const_iterator and "char16*" are
+// The compiler thinks std::u16string::const_iterator and "char16_t*" are
 // equivalent types.
 #define BASE_STRING16_ITERATOR_IS_CHAR16_POINTER
 #endif

include/base/cef_callback.h

@@ -28,40 +28,38 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// A callback is similar in concept to a function pointer: it wraps a runnable
-// object such as a function, method, lambda, or even another callback, allowing
-// the runnable object to be invoked later via the callback object.
-//
-// Unlike function pointers, callbacks are created with base::BindOnce() or
-// base::BindRepeating() and support partial function application.
-//
-// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may
-// be Run() any number of times. |is_null()| is guaranteed to return true for a
-// moved-from callback.
-//
-//   // The lambda takes two arguments, but the first argument |x| is bound at
-//   // callback creation.
-//   base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
-//     return x + y;
-//   }, 1);
-//   // Run() only needs the remaining unbound argument |y|.
-//   printf("1 + 2 = %d\n", std::move(cb).Run(2));  // Prints 3
-//   printf("cb is null? %s\n",
-//          cb.is_null() ? "true" : "false");  // Prints true
-//   std::move(cb).Run(2);  // Crashes since |cb| has already run.
-//
-// Callbacks also support cancellation. A common use is binding the receiver
-// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
-// will be a no-op. Note that |IsCancelled()| and |is_null()| are distinct:
-// simply cancelling a callback will not also make it null.
-//
-// See https://chromium.googlesource.com/chromium/src/+/HEAD/docs/callback.md
-// for the full documentation.
+/// \file
+/// A callback is similar in concept to a function pointer: it wraps a runnable
+/// object such as a function, method, lambda, or even another callback,
+/// allowing the runnable object to be invoked later via the callback object.
+///
+/// Unlike function pointers, callbacks are created with base::BindOnce() or
+/// base::BindRepeating() and support partial function application.
+///
+/// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback
+/// may be Run() any number of times. |is_null()| is guaranteed to return true
+/// for a moved-from callback.
+///
+/// <pre>
+///   // The lambda takes two arguments, but the first argument |x| is bound at
+///   // callback creation.
+///   base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
+///     return x + y;
+///   }, 1);
+///   // Run() only needs the remaining unbound argument |y|.
+///   printf("1 + 2 = %d\n", std::move(cb).Run(2));  // Prints 3
+///   printf("cb is null? %s\n",
+///          cb.is_null() ? "true" : "false");  // Prints true
+///   std::move(cb).Run(2);  // Crashes since |cb| has already run.
+/// </pre>
+///
+/// Callbacks also support cancellation. A common use is binding the receiver
+/// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
+/// will be a no-op. Note that |IsCancelled()| and |is_null()| are distinct:
+/// simply cancelling a callback will not also make it null.
+///
+/// See https://chromium.googlesource.com/chromium/src/+/lkgr/docs/callback.md
+/// for the full documentation.
 
 #ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_H_
 #define CEF_INCLUDE_BASE_CEF_CALLBACK_H_
@@ -69,7 +67,7 @@
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/callback.h"
+#include "base/functional/callback.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
@@ -85,18 +83,18 @@
 namespace base {
 
 template <typename R, typename... Args>
-class OnceCallback<R(Args...)> : public internal::CallbackBase {
+class OnceCallback<R(Args...)> : public cef_internal::CallbackBase {
  public:
   using ResultType = R;
   using RunType = R(Args...);
-  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
-                                  internal::PassingType<Args>...);
+  using PolymorphicInvoke = R (*)(cef_internal::BindStateBase*,
+                                  cef_internal::PassingType<Args>...);
 
   constexpr OnceCallback() = default;
   OnceCallback(std::nullptr_t) = delete;
 
-  explicit OnceCallback(internal::BindStateBase* bind_state)
-      : internal::CallbackBase(bind_state) {}
+  explicit OnceCallback(cef_internal::BindStateBase* bind_state)
+      : cef_internal::CallbackBase(bind_state) {}
 
   OnceCallback(const OnceCallback&) = delete;
   OnceCallback& operator=(const OnceCallback&) = delete;
@@ -105,10 +103,10 @@ class OnceCallback<R(Args...)> : public internal::CallbackBase {
   OnceCallback& operator=(OnceCallback&&) noexcept = default;
 
   OnceCallback(RepeatingCallback<RunType> other)
-      : internal::CallbackBase(std::move(other)) {}
+      : cef_internal::CallbackBase(std::move(other)) {}
 
   OnceCallback& operator=(RepeatingCallback<RunType> other) {
-    static_cast<internal::CallbackBase&>(*this) = std::move(other);
+    static_cast<cef_internal::CallbackBase&>(*this) = std::move(other);
     return *this;
   }
 
@@ -144,7 +142,7 @@ class OnceCallback<R(Args...)> : public internal::CallbackBase {
   OnceCallback<ThenR(Args...)> Then(OnceCallback<ThenR(ThenArgs...)> then) && {
     CHECK(then);
     return BindOnce(
-        internal::ThenHelper<
+        cef_internal::ThenHelper<
             OnceCallback, OnceCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
         std::move(*this), std::move(then));
   }
@@ -157,7 +155,7 @@ class OnceCallback<R(Args...)> : public internal::CallbackBase {
       RepeatingCallback<ThenR(ThenArgs...)> then) && {
     CHECK(then);
     return BindOnce(
-        internal::ThenHelper<
+        cef_internal::ThenHelper<
             OnceCallback,
             RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
         std::move(*this), std::move(then));
@@ -165,18 +163,19 @@ class OnceCallback<R(Args...)> : public internal::CallbackBase {
 };
 
 template <typename R, typename... Args>
-class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
+class RepeatingCallback<R(Args...)>
+    : public cef_internal::CallbackBaseCopyable {
  public:
   using ResultType = R;
   using RunType = R(Args...);
-  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
-                                  internal::PassingType<Args>...);
+  using PolymorphicInvoke = R (*)(cef_internal::BindStateBase*,
+                                  cef_internal::PassingType<Args>...);
 
   constexpr RepeatingCallback() = default;
   RepeatingCallback(std::nullptr_t) = delete;
 
-  explicit RepeatingCallback(internal::BindStateBase* bind_state)
-      : internal::CallbackBaseCopyable(bind_state) {}
+  explicit RepeatingCallback(cef_internal::BindStateBase* bind_state)
+      : cef_internal::CallbackBaseCopyable(bind_state) {}
 
   // Copyable and movable.
   RepeatingCallback(const RepeatingCallback&) = default;
@@ -226,7 +225,7 @@ class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
       RepeatingCallback<ThenR(ThenArgs...)> then) const& {
     CHECK(then);
     return BindRepeating(
-        internal::ThenHelper<
+        cef_internal::ThenHelper<
             RepeatingCallback,
             RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
         *this, std::move(then));
@@ -237,7 +236,7 @@ class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
       RepeatingCallback<ThenR(ThenArgs...)> then) && {
     CHECK(then);
     return BindRepeating(
-        internal::ThenHelper<
+        cef_internal::ThenHelper<
             RepeatingCallback,
             RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
         std::move(*this), std::move(then));

include/base/cef_callback_forward.h

@@ -34,7 +34,7 @@
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/callback_forward.h"
+#include "base/functional/callback_forward.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
@@ -48,9 +48,11 @@ class OnceCallback;
 template <typename Signature>
 class RepeatingCallback;
 
-// Syntactic sugar to make OnceClosure<void()> and RepeatingClosure<void()>
-// easier to declare since they will be used in a lot of APIs with delayed
-// execution.
+///
+/// Syntactic sugar to make OnceClosure<void()> and RepeatingClosure<void()>
+/// easier to declare since they will be used in a lot of APIs with delayed
+/// execution.
+///
 using OnceClosure = OnceCallback<void()>;
 using RepeatingClosure = RepeatingCallback<void()>;
 

include/base/cef_callback_helpers.h

@@ -39,7 +39,7 @@
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/callback_helpers.h"
+#include "base/functional/callback_helpers.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
@@ -52,7 +52,6 @@
 
 #include "include/base/cef_bind.h"
 #include "include/base/cef_callback.h"
-#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
 
 namespace base {
@@ -76,24 +75,32 @@ struct IsOnceCallbackImpl<OnceCallback<R(Args...)>> : std::true_type {};
 
 }  // namespace internal
 
-// IsBaseCallback<T>::value is true when T is any of the Closure or Callback
-// family of types.
+///
+/// IsBaseCallback<T>::value is true when T is any of the Closure or Callback
+/// family of types.
+///
 template <typename T>
 using IsBaseCallback = internal::IsBaseCallbackImpl<std::decay_t<T>>;
 
-// IsOnceCallback<T>::value is true when T is a OnceClosure or OnceCallback
-// type.
+///
+/// IsOnceCallback<T>::value is true when T is a OnceClosure or OnceCallback
+/// type.
+///
 template <typename T>
 using IsOnceCallback = internal::IsOnceCallbackImpl<std::decay_t<T>>;
 
-// SFINAE friendly enabler allowing to overload methods for both Repeating and
-// OnceCallbacks.
-//
-// Usage:
-// template <template <typename> class CallbackType,
-//           ... other template args ...,
-//           typename = EnableIfIsBaseCallback<CallbackType>>
-// void DoStuff(CallbackType<...> cb, ...);
+///
+/// SFINAE friendly enabler allowing to overload methods for both Repeating and
+/// OnceCallbacks.
+///
+/// Usage:
+/// <pre>
+///   template <template <typename> class CallbackType,
+///             ... other template args ...,
+///             typename = EnableIfIsBaseCallback<CallbackType>>
+///   void DoStuff(CallbackType<...> cb, ...);
+/// </pre>
+///
 template <template <typename> class CallbackType>
 using EnableIfIsBaseCallback =
     std::enable_if_t<IsBaseCallback<CallbackType<void()>>::value>;
@@ -130,13 +137,16 @@ class OnceCallbackHolder final {
 
 }  // namespace internal
 
-// Wraps the given OnceCallback into a RepeatingCallback that relays its
-// invocation to the original OnceCallback on the first invocation. The
-// following invocations are just ignored.
-//
-// Note that this deliberately subverts the Once/Repeating paradigm of Callbacks
-// but helps ease the migration from old-style Callbacks. Avoid if possible; use
-// if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593
+///
+/// Wraps the given OnceCallback into a RepeatingCallback that relays its
+/// invocation to the original OnceCallback on the first invocation. The
+/// following invocations are just ignored.
+///
+/// Note that this deliberately subverts the Once/Repeating paradigm of
+/// Callbacks but helps ease the migration from old-style Callbacks. Avoid if
+/// possible; use if necessary for migration.
+///
+// TODO(tzik): Remove it. https://crbug.com/730593
 template <typename... Args>
 RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
     OnceCallback<void(Args...)> callback) {
@@ -146,9 +156,11 @@ RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
                                              /*ignore_extra_runs=*/true));
 }
 
-// Wraps the given OnceCallback and returns two OnceCallbacks with an identical
-// signature. On first invokation of either returned callbacks, the original
-// callback is invoked. Invoking the remaining callback results in a crash.
+///
+/// Wraps the given OnceCallback and returns two OnceCallbacks with an identical
+/// signature. On first invokation of either returned callbacks, the original
+/// callback is invoked. Invoking the remaining callback results in a crash.
+///
 template <typename... Args>
 std::pair<OnceCallback<void(Args...)>, OnceCallback<void(Args...)>>
 SplitOnceCallback(OnceCallback<void(Args...)> callback) {
@@ -159,10 +171,12 @@ SplitOnceCallback(OnceCallback<void(Args...)> callback) {
   return std::make_pair(wrapped_once, wrapped_once);
 }
 
-// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
-// that the Closure is executed no matter how the current scope exits.
-// If you are looking for "ScopedCallback", "CallbackRunner", or
-// "CallbackScoper" this is the class you want.
+///
+/// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
+/// that the Closure is executed no matter how the current scope exits.
+/// If you are looking for "ScopedCallback", "CallbackRunner", or
+/// "CallbackScoper" this is the class you want.
+///
 class ScopedClosureRunner {
  public:
   ScopedClosureRunner();
@@ -184,13 +198,15 @@ class ScopedClosureRunner {
   void ReplaceClosure(OnceClosure closure);
 
   // Releases the Closure without calling.
-  OnceClosure Release() WARN_UNUSED_RESULT;
+  [[nodiscard]] OnceClosure Release();
 
  private:
   OnceClosure closure_;
 };
 
-// Creates a null callback.
+///
+/// Creates a null callback.
+///
 class NullCallback {
  public:
   template <typename R, typename... Args>
@@ -203,7 +219,9 @@ class NullCallback {
   }
 };
 
-// Creates a callback that does nothing when called.
+///
+/// Creates a callback that does nothing when called.
+///
 class DoNothing {
  public:
   template <typename... Args>
@@ -226,9 +244,11 @@ class DoNothing {
   }
 };
 
-// Useful for creating a Closure that will delete a pointer when invoked. Only
-// use this when necessary. In most cases MessageLoop::DeleteSoon() is a better
-// fit.
+///
+/// Useful for creating a Closure that will delete a pointer when invoked. Only
+/// use this when necessary. In most cases MessageLoop::DeleteSoon() is a better
+/// fit.
+///
 template <typename T>
 void DeletePointer(T* obj) {
   delete obj;

include/base/cef_callback_list.h

@@ -28,54 +28,57 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// OVERVIEW:
-//
-// A container for a list of callbacks. Provides callers the ability to manually
-// or automatically unregister callbacks at any time, including during callback
-// notification.
-//
-// TYPICAL USAGE:
-//
-// class MyWidget {
-//  public:
-//   using CallbackList = base::RepeatingCallbackList<void(const Foo&)>;
-//
-//   // Registers |cb| to be called whenever NotifyFoo() is executed.
-//   CallbackListSubscription RegisterCallback(CallbackList::CallbackType cb) {
-//     return callback_list_.Add(std::move(cb));
-//   }
-//
-//  private:
-//   // Calls all registered callbacks, with |foo| as the supplied arg.
-//   void NotifyFoo(const Foo& foo) {
-//     callback_list_.Notify(foo);
-//   }
-//
-//   CallbackList callback_list_;
-// };
-//
-//
-// class MyWidgetListener {
-//  private:
-//   void OnFoo(const Foo& foo) {
-//     // Called whenever MyWidget::NotifyFoo() is executed, unless
-//     // |foo_subscription_| has been destroyed.
-//   }
-//
-//   // Automatically deregisters the callback when deleted (e.g. in
-//   // ~MyWidgetListener()).  Unretained(this) is safe here since the
-//   // ScopedClosureRunner does not outlive |this|.
-//   CallbackListSubscription foo_subscription_ =
-//       MyWidget::Get()->RegisterCallback(
-//           base::BindRepeating(&MyWidgetListener::OnFoo,
-//                               base::Unretained(this)));
-// };
-//
-// UNSUPPORTED:
-//
-// * Destroying the CallbackList during callback notification.
-//
-// This is possible to support, but not currently necessary.
+///
+/// \file
+/// A container for a list of callbacks. Provides callers the ability to
+/// manually or automatically unregister callbacks at any time, including during
+/// callback notification.
+///
+/// TYPICAL USAGE:
+///
+/// <pre>
+/// class MyWidget {
+///  public:
+///   using CallbackList = base::RepeatingCallbackList<void(const Foo&)>;
+///
+///   // Registers |cb| to be called whenever NotifyFoo() is executed.
+///   CallbackListSubscription RegisterCallback(CallbackList::CallbackType cb) {
+///     return callback_list_.Add(std::move(cb));
+///   }
+///
+///  private:
+///   // Calls all registered callbacks, with |foo| as the supplied arg.
+///   void NotifyFoo(const Foo& foo) {
+///     callback_list_.Notify(foo);
+///   }
+///
+///   CallbackList callback_list_;
+/// };
+///
+///
+/// class MyWidgetListener {
+///  private:
+///   void OnFoo(const Foo& foo) {
+///     // Called whenever MyWidget::NotifyFoo() is executed, unless
+///     // |foo_subscription_| has been destroyed.
+///   }
+///
+///   // Automatically deregisters the callback when deleted (e.g. in
+///   // ~MyWidgetListener()).  Unretained(this) is safe here since the
+///   // ScopedClosureRunner does not outlive |this|.
+///   CallbackListSubscription foo_subscription_ =
+///       MyWidget::Get()->RegisterCallback(
+///           base::BindRepeating(&MyWidgetListener::OnFoo,
+///                               base::Unretained(this)));
+/// };
+/// </pre>
+///
+/// UNSUPPORTED:
+///
+/// * Destroying the CallbackList during callback notification.
+///
+/// This is possible to support, but not currently necessary.
+///
 
 #ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
 #define CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
@@ -83,7 +86,7 @@
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/callback_list.h"
+#include "base/functional/callback_list.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
@@ -98,7 +101,6 @@
 #include "include/base/cef_bind.h"
 #include "include/base/cef_callback.h"
 #include "include/base/cef_callback_helpers.h"
-#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_weak_ptr.h"
 
@@ -191,7 +193,7 @@ class CallbackListBase {
 
   // Registers |cb| for future notifications. Returns a CallbackListSubscription
   // whose destruction will cancel |cb|.
-  CallbackListSubscription Add(CallbackType cb) WARN_UNUSED_RESULT {
+  [[nodiscard]] CallbackListSubscription Add(CallbackType cb) {
     DCHECK(!cb.is_null());
     return CallbackListSubscription(base::BindOnce(
         &CallbackListBase::CancelCallback, weak_ptr_factory_.GetWeakPtr(),
@@ -240,8 +242,9 @@ class CallbackListBase {
   // the reentrant Notify() call.
   template <typename... RunArgs>
   void Notify(RunArgs&&... args) {
-    if (empty())
+    if (empty()) {
       return;  // Nothing to do.
+    }
 
     {
       AutoReset<bool> iterating(&iterating_, true);
@@ -255,18 +258,20 @@ class CallbackListBase {
         });
       };
       for (auto it = next_valid(callbacks_.begin()); it != callbacks_.end();
-           it = next_valid(it))
+           it = next_valid(it)) {
         // NOTE: Intentionally does not call std::forward<RunArgs>(args)...,
         // since that would allow move-only arguments.
         static_cast<CallbackListImpl*>(this)->RunCallback(it++, args...);
+      }
     }
 
     // Re-entrant invocations shouldn't prune anything from the list. This can
     // invalidate iterators from underneath higher call frames. It's safe to
     // simply do nothing, since the outermost frame will continue through here
     // and prune all null callbacks below.
-    if (iterating_)
+    if (iterating_) {
       return;
+    }
 
     // Any null callbacks remaining in the list were canceled due to
     // Subscription destruction during iteration, and can safely be erased now.
@@ -280,8 +285,9 @@ class CallbackListBase {
     // that were executed above have all been removed regardless of whether
     // they're counted in |erased_callbacks_|.
     if (removal_callback_ &&
-        (erased_callbacks || IsOnceCallback<CallbackType>::value))
+        (erased_callbacks || IsOnceCallback<CallbackType>::value)) {
       removal_callback_.Run();  // May delete |this|!
+    }
   }
 
  protected:
@@ -293,8 +299,9 @@ class CallbackListBase {
  private:
   // Cancels the callback pointed to by |it|, which is guaranteed to be valid.
   void CancelCallback(const typename Callbacks::iterator& it) {
-    if (static_cast<CallbackListImpl*>(this)->CancelNullCallback(it))
+    if (static_cast<CallbackListImpl*>(this)->CancelNullCallback(it)) {
       return;
+    }
 
     if (iterating_) {
       // Calling erase() here is unsafe, since the loop in Notify() may be
@@ -304,8 +311,9 @@ class CallbackListBase {
       it->Reset();
     } else {
       callbacks_.erase(it);
-      if (removal_callback_)
+      if (removal_callback_) {
         removal_callback_.Run();  // May delete |this|!
+      }
     }
   }
 
@@ -382,9 +390,9 @@ class RepeatingCallbackList
   }
 };
 
-// Syntactic sugar to parallel that used for Callbacks.
-// ClosureList explicitly not provided since it is not used, and CallbackList
-// is deprecated. {Once,Repeating}ClosureList should instead be used.
+///
+/// Syntactic sugar to parallel that used for Callbacks.
+///
 using OnceClosureList = OnceCallbackList<void()>;
 using RepeatingClosureList = RepeatingCallbackList<void()>;
 

include/base/cef_cancelable_callback.h

@@ -28,44 +28,51 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// CancelableCallback is a wrapper around base::Callback that allows
-// cancellation of a callback. CancelableCallback takes a reference on the
-// wrapped callback until this object is destroyed or Reset()/Cancel() are
-// called.
-//
-// NOTE:
-//
-// Calling CancelableCallback::Cancel() brings the object back to its natural,
-// default-constructed state, i.e., CancelableCallback::callback() will return
-// a null callback.
-//
-// THREAD-SAFETY:
-//
-// CancelableCallback objects must be created on, posted to, cancelled on, and
-// destroyed on the same thread.
-//
-//
-// EXAMPLE USAGE:
-//
-// In the following example, the test is verifying that RunIntensiveTest()
-// Quit()s the message loop within 4 seconds. The cancelable callback is posted
-// to the message loop, the intensive test runs, the message loop is run,
-// then the callback is cancelled.
-//
-// RunLoop run_loop;
-//
-// void TimeoutCallback(const std::string& timeout_message) {
-//   FAIL() << timeout_message;
-//   run_loop.QuitWhenIdle();
-// }
-//
-// CancelableOnceClosure timeout(
-//     base::BindOnce(&TimeoutCallback, "Test timed out."));
-// ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, timeout.callback(),
-//                                                TimeDelta::FromSeconds(4));
-// RunIntensiveTest();
-// run_loop.Run();
-// timeout.Cancel();  // Hopefully this is hit before the timeout callback runs.
+///
+/// \file
+/// CancelableCallback is a wrapper around base::Callback that allows
+/// cancellation of a callback. CancelableCallback takes a reference on the
+/// wrapped callback until this object is destroyed or Reset()/Cancel() are
+/// called.
+///
+/// NOTE:
+///
+/// Calling CancelableCallback::Cancel() brings the object back to its natural,
+/// default-constructed state, i.e., CancelableCallback::callback() will return
+/// a null callback.
+///
+/// THREAD-SAFETY:
+///
+/// CancelableCallback objects must be created on, posted to, cancelled on, and
+/// destroyed on the same thread.
+///
+///
+/// EXAMPLE USAGE:
+///
+/// In the following example, the test is verifying that RunIntensiveTest()
+/// Quit()s the message loop within 4 seconds. The cancelable callback is posted
+/// to the message loop, the intensive test runs, the message loop is run,
+/// then the callback is cancelled.
+///
+/// <pre>
+///   RunLoop run_loop;
+///
+///   void TimeoutCallback(const std::string& timeout_message) {
+///     FAIL() << timeout_message;
+///     run_loop.QuitWhenIdle();
+///   }
+///
+///   CancelableOnceClosure timeout(
+///       base::BindOnce(&TimeoutCallback, "Test timed out."));
+///   ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
+///                                                  timeout.callback(),
+///                                                  TimeDelta::FromSeconds(4));
+///   RunIntensiveTest();
+///   run_loop.Run();
+///   // Hopefully this is hit before the timeout callback runs.
+///   timeout.Cancel();
+/// </pre>
+///
 
 #ifndef CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
 #define CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
@@ -126,8 +133,9 @@ class CancelableCallbackImpl {
 
   // Returns a callback that can be disabled by calling Cancel().
   CallbackType callback() const {
-    if (!callback_)
+    if (!callback_) {
       return CallbackType();
+    }
     CallbackType forwarder;
     MakeForwarder(&forwarder);
     return forwarder;
@@ -166,8 +174,10 @@ class CancelableCallbackImpl {
 
 }  // namespace internal
 
-// Consider using base::WeakPtr directly instead of base::CancelableCallback for
-// the task cancellation.
+///
+/// Consider using base::WeakPtr directly instead of base::CancelableCallback
+/// for the task cancellation.
+///
 template <typename Signature>
 using CancelableOnceCallback =
     internal::CancelableCallbackImpl<OnceCallback<Signature>>;

include/base/cef_compiler_specific.h

@@ -251,13 +251,6 @@
 #define HAS_FEATURE(FEATURE) 0
 #endif
 
-// Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional.
-#if defined(__clang__)
-#define FALLTHROUGH [[clang::fallthrough]]
-#else
-#define FALLTHROUGH
-#endif
-
 #if defined(COMPILER_GCC)
 #define PRETTY_FUNCTION __PRETTY_FUNCTION__
 #elif defined(COMPILER_MSVC)
@@ -386,26 +379,4 @@ inline constexpr bool AnalyzerAssumeTrue(bool arg) {
 #endif
 
 #endif  // !USING_CHROMIUM_INCLUDES
-
-// Annotate a function indicating the caller must examine the return value.
-// Use like:
-//   int foo() WARN_UNUSED_RESULT;
-// To explicitly ignore a result, use std::ignore from <tuple>.
-// Alternately use `[[nodiscard]]` with code that supports C++17.
-#undef WARN_UNUSED_RESULT
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
-#else
-#define WARN_UNUSED_RESULT
-#endif
-
-// Annotate a variable indicating it's ok if the variable is not used.
-// (Typically used to silence a compiler warning when the assignment
-// is important for some other reason.)
-// Use like:
-//   int x = ...;
-//   ALLOW_UNUSED_LOCAL(x);
-// Alternately use `[[maybe_unused]]` with code that supports C++17.
-#define ALLOW_UNUSED_LOCAL(x) (void)x
-
 #endif  // CEF_INCLUDE_BASE_CEF_COMPILER_SPECIFIC_H_

include/base/cef_cxx17_backports.h

@@ -1,133 +0,0 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. Portions copyright (c) 2021
-// Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-
-#ifndef CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_
-#define CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_
-#pragma once
-
-#if defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-// TODO(cef): Change to "base/cxx17_backports.h" in M93.
-#include "base/stl_util.h"
-#else  // !USING_CHROMIUM_INCLUDES
-// The following is substantially similar to the Chromium implementation.
-// If the Chromium implementation diverges the below implementation should be
-// updated to match.
-
-#include <array>
-#include <initializer_list>
-#include <memory>
-#include <string>
-
-namespace base {
-
-// C++14 implementation of C++17's std::size():
-// http://en.cppreference.com/w/cpp/iterator/size
-template <typename Container>
-constexpr auto size(const Container& c) -> decltype(c.size()) {
-  return c.size();
-}
-
-template <typename T, size_t N>
-constexpr size_t size(const T (&array)[N]) noexcept {
-  return N;
-}
-
-// C++14 implementation of C++17's std::empty():
-// http://en.cppreference.com/w/cpp/iterator/empty
-template <typename Container>
-constexpr auto empty(const Container& c) -> decltype(c.empty()) {
-  return c.empty();
-}
-
-template <typename T, size_t N>
-constexpr bool empty(const T (&array)[N]) noexcept {
-  return false;
-}
-
-template <typename T>
-constexpr bool empty(std::initializer_list<T> il) noexcept {
-  return il.size() == 0;
-}
-
-// C++14 implementation of C++17's std::data():
-// http://en.cppreference.com/w/cpp/iterator/data
-template <typename Container>
-constexpr auto data(Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-// std::basic_string::data() had no mutable overload prior to C++17 [1].
-// Hence this overload is provided.
-// Note: str[0] is safe even for empty strings, as they are guaranteed to be
-// null-terminated [2].
-//
-// [1] http://en.cppreference.com/w/cpp/string/basic_string/data
-// [2] http://en.cppreference.com/w/cpp/string/basic_string/operator_at
-template <typename CharT, typename Traits, typename Allocator>
-CharT* data(std::basic_string<CharT, Traits, Allocator>& str) {
-  return std::addressof(str[0]);
-}
-
-template <typename Container>
-constexpr auto data(const Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-template <typename T, size_t N>
-constexpr T* data(T (&array)[N]) noexcept {
-  return array;
-}
-
-template <typename T>
-constexpr const T* data(std::initializer_list<T> il) noexcept {
-  return il.begin();
-}
-
-// std::array::data() was not constexpr prior to C++17 [1].
-// Hence these overloads are provided.
-//
-// [1] https://en.cppreference.com/w/cpp/container/array/data
-template <typename T, size_t N>
-constexpr T* data(std::array<T, N>& array) noexcept {
-  return !array.empty() ? &array[0] : nullptr;
-}
-
-template <typename T, size_t N>
-constexpr const T* data(const std::array<T, N>& array) noexcept {
-  return !array.empty() ? &array[0] : nullptr;
-}
-
-}  // namespace base
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_

include/base/cef_dump_without_crashing.h

@@ -0,0 +1,76 @@
+// Copyright (c) 2024 Marshall A. Greenblatt. Portions copyright (c) 2012
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+///
+/// \file
+/// Provides functions for generating crash dumps.
+///
+/// NOTE: The contents of this file are only available to applications that link
+/// against the libcef_dll_wrapper target.
+///
+/// NOTE: Ensure crash reporting is configured before use. See
+/// https://bitbucket.org/chromiumembedded/cef/wiki/CrashReporting.md for more
+/// information
+///
+/// WARNING: Crash reporting should not be used in the main/browser process
+/// before calling CefInitialize or in sub-processes before CefExecuteProcess.
+///
+
+#ifndef CEF_INCLUDE_BASE_CEF_DUMP_WITHOUT_CRASHING_H_
+#define CEF_INCLUDE_BASE_CEF_DUMP_WITHOUT_CRASHING_H_
+#pragma once
+
+constexpr long long kOneDayInMilliseconds = 86400000;
+
+///
+/// CefDumpWithoutCrashing allows for generating crash dumps with a throttling
+/// mechanism, preventing frequent dumps from being generated in a short period
+/// of time from the same location. The |function_name|, |file_name|, and
+/// |line_number| determine the location of the dump. The
+/// |mseconds_between_dumps| is an interval between consecutive dumps in
+/// milliseconds from the same location.
+///
+/// Returns true if the dump was successfully generated, false otherwise.
+///
+bool CefDumpWithoutCrashing(
+    long long mseconds_between_dumps = kOneDayInMilliseconds,
+    const char* function_name = __builtin_FUNCTION(),
+    const char* file_name = __builtin_FILE(),
+    int line_number = __builtin_LINE());
+
+///
+/// CefDumpWithoutCrashingUnthrottled allows for immediate crash dumping without
+/// any throttling constraints.
+///
+/// Returns true if the dump was successfully generated, false otherwise.
+///
+bool CefDumpWithoutCrashingUnthrottled();
+
+#endif  // CEF_INCLUDE_BASE_CEF_DUMP_WITHOUT_CRASHING_H_

include/base/cef_lock.h

@@ -47,9 +47,11 @@
 namespace base {
 namespace cef_internal {
 
-// A convenient wrapper for an OS specific critical section.  The only real
-// intelligence in this class is in debug mode for the support for the
-// AssertAcquired() method.
+///
+/// A convenient wrapper for an OS specific critical section.  The only real
+/// intelligence in this class is in debug mode for the support for the
+/// AssertAcquired() method.
+///
 class Lock {
  public:
 #if !DCHECK_IS_ON()  // Optimized wrapper implementation
@@ -62,10 +64,12 @@ class Lock {
   void Acquire() { lock_.Lock(); }
   void Release() { lock_.Unlock(); }
 
-  // If the lock is not held, take it and return true. If the lock is already
-  // held by another thread, immediately return false. This must not be called
-  // by a thread already holding the lock (what happens is undefined and an
-  // assertion may fail).
+  ///
+  /// If the lock is not held, take it and return true. If the lock is already
+  /// held by another thread, immediately return false. This must not be called
+  /// by a thread already holding the lock (what happens is undefined and an
+  /// assertion may fail).
+  ///
   bool Try() { return lock_.Try(); }
 
   // Null implementation if not debug.
@@ -116,7 +120,9 @@ class Lock {
   LockImpl lock_;
 };
 
-// A helper class that acquires the given Lock while the AutoLock is in scope.
+///
+/// A helper class that acquires the given Lock while the AutoLock is in scope.
+///
 class AutoLock {
  public:
   struct AlreadyAcquired {};
@@ -139,8 +145,10 @@ class AutoLock {
   Lock& lock_;
 };
 
-// AutoUnlock is a helper that will Release() the |lock| argument in the
-// constructor, and re-Acquire() it in the destructor.
+///
+/// AutoUnlock is a helper that will Release() the |lock| argument in the
+/// constructor, and re-Acquire() it in the destructor.
+///
 class AutoUnlock {
  public:
   explicit AutoUnlock(Lock& lock) : lock_(lock) {

include/base/cef_logging.h

@@ -27,110 +27,130 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// The contents of this file are only available to applications that link
-// against the libcef_dll_wrapper target.
-//
-// WARNING: Logging macros should not be used in the main/browser process before
-// calling CefInitialize or in sub-processes before calling CefExecuteProcess.
-//
-// Instructions
-// ------------
-//
-// Make a bunch of macros for logging.  The way to log things is to stream
-// things to LOG(<a particular severity level>).  E.g.,
-//
-//   LOG(INFO) << "Found " << num_cookies << " cookies";
-//
-// You can also do conditional logging:
-//
-//   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
-//
-// The CHECK(condition) macro is active in both debug and release builds and
-// effectively performs a LOG(FATAL) which terminates the process and
-// generates a crashdump unless a debugger is attached.
-//
-// There are also "debug mode" logging macros like the ones above:
-//
-//   DLOG(INFO) << "Found cookies";
-//
-//   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
-//
-// All "debug mode" logging is compiled away to nothing for non-debug mode
-// compiles.  LOG_IF and development flags also work well together
-// because the code can be compiled away sometimes.
-//
-// We also have
-//
-//   LOG_ASSERT(assertion);
-//   DLOG_ASSERT(assertion);
-//
-// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
-//
-// There are "verbose level" logging macros.  They look like
-//
-//   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
-//   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
-//
-// These always log at the INFO log level (when they log at all).
-// The verbose logging can also be turned on module-by-module.  For instance,
-//    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
-// will cause:
-//   a. VLOG(2) and lower messages to be printed from profile.{h,cc}
-//   b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
-//   c. VLOG(3) and lower messages to be printed from files prefixed with
-//      "browser"
-//   d. VLOG(4) and lower messages to be printed from files under a
-//     "chromeos" directory.
-//   e. VLOG(0) and lower messages to be printed from elsewhere
-//
-// The wildcarding functionality shown by (c) supports both '*' (match
-// 0 or more characters) and '?' (match any single character)
-// wildcards.  Any pattern containing a forward or backward slash will
-// be tested against the whole pathname and not just the module.
-// E.g., "*/foo/bar/*=2" would change the logging level for all code
-// in source files under a "foo/bar" directory.
-//
-// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
-//
-//   if (VLOG_IS_ON(2)) {
-//     // do some logging preparation and logging
-//     // that can't be accomplished with just VLOG(2) << ...;
-//   }
-//
-// There is also a VLOG_IF "verbose level" condition macro for sample
-// cases, when some extra computation and preparation for logs is not
-// needed.
-//
-//   VLOG_IF(1, (size > 1024))
-//      << "I'm printed when size is more than 1024 and when you run the "
-//         "program with --v=1 or more";
-//
-// We also override the standard 'assert' to use 'DLOG_ASSERT'.
-//
-// Lastly, there is:
-//
-//   PLOG(ERROR) << "Couldn't do foo";
-//   DPLOG(ERROR) << "Couldn't do foo";
-//   PLOG_IF(ERROR, cond) << "Couldn't do foo";
-//   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
-//   PCHECK(condition) << "Couldn't do foo";
-//   DPCHECK(condition) << "Couldn't do foo";
-//
-// which append the last system error to the message in string form (taken from
-// GetLastError() on Windows and errno on POSIX).
-//
-// The supported severity levels for macros that allow you to specify one
-// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
-//
-// Very important: logging a message at the FATAL severity level causes
-// the program to terminate (after the message is logged).
-//
-// There is the special severity of DFATAL, which logs FATAL in debug mode,
-// ERROR in normal mode.
-//
+
+///
+/// \file
+/// A bunch of macros for logging.
+///
+/// NOTE: The contents of this file are only available to applications that link
+/// against the libcef_dll_wrapper target.
+///
+/// WARNING: Logging macros should not be used in the main/browser process
+/// before calling CefInitialize or in sub-processes before calling
+/// CefExecuteProcess.
+///
+/// INSTRUCTIONS:
+///
+/// The way to log things is to stream things to LOG(<a particular severity
+/// level>). E.g.,
+///
+/// <pre>
+///   LOG(INFO) << "Found " << num_cookies << " cookies";
+/// </pre>
+///
+/// You can also do conditional logging:
+///
+/// <pre>
+///   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+/// </pre>
+///
+/// The CHECK(condition) macro is active in both debug and release builds and
+/// effectively performs a LOG(FATAL) which terminates the process and
+/// generates a crashdump unless a debugger is attached.
+///
+/// There are also "debug mode" logging macros like the ones above:
+///
+/// <pre>
+///   DLOG(INFO) << "Found cookies";
+///
+///   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+/// </pre>
+///
+/// All "debug mode" logging is compiled away to nothing for non-debug mode
+/// compiles.  LOG_IF and development flags also work well together
+/// because the code can be compiled away sometimes.
+///
+/// We also have
+///
+/// <pre>
+///   LOG_ASSERT(assertion);
+///   DLOG_ASSERT(assertion);
+/// </pre>
+///
+/// which is syntactic sugar for "{,D}LOG_IF(FATAL, assert fails) << assertion;"
+///
+/// There are "verbose level" logging macros.  They look like
+///
+/// <pre>
+///   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
+///   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
+/// </pre>
+///
+/// These always log at the INFO log level (when they log at all).
+/// The verbose logging can also be turned on module-by-module.  For instance,
+/// <pre>
+///    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
+/// </pre>
+/// will cause:
+/// 1. VLOG(2) and lower messages to be printed from profile.{h,cc}
+/// 2. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
+/// 3. VLOG(3) and lower messages to be printed from files prefixed with
+///    "browser"
+/// 4. VLOG(4) and lower messages to be printed from files under a
+///    "chromeos" directory.
+/// 5. VLOG(0) and lower messages to be printed from elsewhere
+///
+/// The wildcarding functionality shown by (c) supports both '*' (match
+/// 0 or more characters) and '?' (match any single character)
+/// wildcards.  Any pattern containing a forward or backward slash will
+/// be tested against the whole pathname and not just the module.
+/// E.g., "*/foo/bar/*=2" would change the logging level for all code
+/// in source files under a "foo/bar" directory.
+///
+/// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
+///
+/// <pre>
+///   if (VLOG_IS_ON(2)) {
+///     // do some logging preparation and logging
+///     // that can't be accomplished with just VLOG(2) << ...;
+///   }
+/// </pre>
+///
+/// There is also a VLOG_IF "verbose level" condition macro for sample
+/// cases, when some extra computation and preparation for logs is not
+/// needed.
+///
+/// <pre>
+///   VLOG_IF(1, (size > 1024))
+///      << "I'm printed when size is more than 1024 and when you run the "
+///         "program with --v=1 or more";
+/// </pre>
+///
+/// We also override the standard 'assert' to use 'DLOG_ASSERT'.
+///
+/// Lastly, there is:
+///
+/// <pre>
+///   PLOG(ERROR) << "Couldn't do foo";
+///   DPLOG(ERROR) << "Couldn't do foo";
+///   PLOG_IF(ERROR, cond) << "Couldn't do foo";
+///   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
+///   PCHECK(condition) << "Couldn't do foo";
+///   DPCHECK(condition) << "Couldn't do foo";
+/// </pre>
+///
+/// which append the last system error to the message in string form (taken from
+/// GetLastError() on Windows and errno on POSIX).
+///
+/// The supported severity levels for macros that allow you to specify one
+/// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
+///
+/// Very important: logging a message at the FATAL severity level causes
+/// the program to terminate (after the message is logged).
+///
+/// There is the special severity of DFATAL, which logs FATAL in debug mode,
+/// ERROR in normal mode.
+///
 
 #ifndef CEF_INCLUDE_BASE_CEF_LOGGING_H_
 #define CEF_INCLUDE_BASE_CEF_LOGGING_H_
@@ -703,6 +723,13 @@ std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
 inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
   return out << wstr.c_str();
 }
+#if defined(WCHAR_T_IS_32_BIT)
+std::ostream& operator<<(std::ostream& out, const char16_t* wstr);
+#elif defined(WCHAR_T_IS_16_BIT)
+inline std::ostream& operator<<(std::ostream& out, const char16_t* wstr) {
+  return operator<<(out, reinterpret_cast<const wchar_t*>(wstr));
+}
+#endif
 
 // The NOTIMPLEMENTED() macro annotates codepaths which have
 // not been implemented yet.

include/base/cef_macros.h

@@ -38,8 +38,8 @@
 // updated to match.
 
 // ALL DISALLOW_xxx MACROS ARE DEPRECATED; DO NOT USE IN NEW CODE.
-// Use explicit deletions instead.  See the section on copyability/movability in
-// //styleguide/c++/c++-dos-and-donts.md for more information.
+// Use explicit deletions instead. For more information see
+// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++-dos-and-donts.md#explicitly-declare-class-copyability_movability
 
 // DEPRECATED: See above. Makes a class uncopyable.
 #define DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete

include/base/cef_platform_thread.h

@@ -43,23 +43,26 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include "include/base/cef_basictypes.h"
 #include "include/base/cef_build.h"
 #include "include/internal/cef_thread_internal.h"
 
 namespace base {
 
-// Used for logging. Always an integer value.
+///
+/// Used for logging. Always an integer value.
+///
 typedef cef_platform_thread_id_t PlatformThreadId;
 
-// Used for thread checking and debugging.
-// Meant to be as fast as possible.
-// These are produced by PlatformThread::CurrentRef(), and used to later
-// check if we are on the same thread or not by using ==. These are safe
-// to copy between threads, but can't be copied to another process as they
-// have no meaning there. Also, the internal identifier can be re-used
-// after a thread dies, so a PlatformThreadRef cannot be reliably used
-// to distinguish a new thread from an old, dead thread.
+///
+/// Used for thread checking and debugging.
+/// Meant to be as fast as possible.
+/// These are produced by PlatformThread::CurrentRef(), and used to later
+/// check if we are on the same thread or not by using ==. These are safe
+/// to copy between threads, but can't be copied to another process as they
+/// have no meaning there. Also, the internal identifier can be re-used
+/// after a thread dies, so a PlatformThreadRef cannot be reliably used
+/// to distinguish a new thread from an old, dead thread.
+///
 class PlatformThreadRef {
  public:
   typedef cef_platform_thread_handle_t RefType;
@@ -76,18 +79,24 @@ class PlatformThreadRef {
   RefType id_;
 };
 
-// A namespace for low-level thread functions.
-// Chromium uses a class with static methods but CEF uses an actual namespace
-// to avoid linker problems with the sandbox libaries on Windows.
+///
+/// A namespace for low-level thread functions.
+/// Chromium uses a class with static methods but CEF uses an actual namespace
+/// to avoid linker problems with the sandbox libaries on Windows.
+///
 namespace PlatformThread {
 
-// Gets the current thread id, which may be useful for logging purposes.
+///
+/// Gets the current thread id, which may be useful for logging purposes.
+///
 inline PlatformThreadId CurrentId() {
   return cef_get_current_platform_thread_id();
 }
 
-// Gets the current thread reference, which can be used to check if
-// we're on the right thread quickly.
+///
+/// Gets the current thread reference, which can be used to check if
+/// we're on the right thread quickly.
+///
 inline PlatformThreadRef CurrentRef() {
   return PlatformThreadRef(cef_get_current_platform_thread_handle());
 }

include/base/cef_ref_counted.h

@@ -50,7 +50,6 @@
 #include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_scoped_refptr.h"
-#include "include/base/cef_template_util.h"
 #include "include/base/cef_thread_checker.h"
 
 namespace base {
@@ -105,13 +104,16 @@ class RefCountedBase {
 
 #if DCHECK_IS_ON()
     DCHECK(!in_dtor_);
-    if (ref_count_ == 0)
+    if (ref_count_ == 0) {
       in_dtor_ = true;
+    }
 
-    if (ref_count_ >= 1)
+    if (ref_count_ >= 1) {
       DCHECK(CalledOnValidThread());
-    if (ref_count_ == 1)
+    }
+    if (ref_count_ == 1) {
       thread_checker_.DetachFromThread();
+    }
 #endif
 
     return ref_count_ == 0;
@@ -290,52 +292,26 @@ class ScopedAllowCrossThreadRefCountAccess final {
 using ScopedAllowCrossThreadRefCountAccess =
     cef_subtle::ScopedAllowCrossThreadRefCountAccess;
 
-//
-// A base class for reference counted classes.  Otherwise, known as a cheap
-// knock-off of WebKit's RefCounted<T> class.  To use this, just extend your
-// class from it like so:
-//
-//   class MyFoo : public base::RefCounted<MyFoo> {
-//    ...
-//    private:
-//     friend class base::RefCounted<MyFoo>;
-//     ~MyFoo();
-//   };
-//
-// Usage Notes:
-// 1. You should always make your destructor non-public, to avoid any code
-// deleting the object accidentally while there are references to it.
-// 2. You should always make the ref-counted base class a friend of your class,
-// so that it can access the destructor.
-//
-// The ref count manipulation to RefCounted is NOT thread safe and has DCHECKs
-// to trap unsafe cross thread usage. A subclass instance of RefCounted can be
-// passed to another execution thread only when its ref count is 1. If the ref
-// count is more than 1, the RefCounted class verifies the ref updates are made
-// on the same execution thread as the previous ones. The subclass can also
-// manually call IsOnValidThread to trap other non-thread-safe accesses; see
-// the documentation for that method.
-//
-//
-// The reference count starts from zero by default, and we intended to migrate
-// to start-from-one ref count. Put REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() to
-// the ref counted class to opt-in.
-//
-// If an object has start-from-one ref count, the first scoped_refptr need to be
-// created by base::AdoptRef() or base::MakeRefCounted(). We can use
-// base::MakeRefCounted() to create create both type of ref counted object.
-//
-// The motivations to use start-from-one ref count are:
-//  - Start-from-one ref count doesn't need the ref count increment for the
-//    first reference.
-//  - It can detect an invalid object acquisition for a being-deleted object
-//    that has zero ref count. That tends to happen on custom deleter that
-//    delays the deletion.
-//    TODO(tzik): Implement invalid acquisition detection.
-//  - Behavior parity to Blink's WTF::RefCounted, whose count starts from one.
-//    And start-from-one ref count is a step to merge WTF::RefCounted into
-//    base::RefCounted.
-//
+///
+/// The reference count starts from zero by default, and we intended to migrate
+/// to start-from-one ref count. Put REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() to
+/// the ref counted class to opt-in.
+///
+/// If an object has start-from-one ref count, the first scoped_refptr need to
+/// be created by base::AdoptRef() or base::MakeRefCounted(). We can use
+/// base::MakeRefCounted() to create create both type of ref counted object.
+///
+/// The motivations to use start-from-one ref count are:
+///  - Start-from-one ref count doesn't need the ref count increment for the
+///    first reference.
+///  - It can detect an invalid object acquisition for a being-deleted object
+///    that has zero ref count. That tends to happen on custom deleter that
+///    delays the deletion.
+///    TODO(tzik): Implement invalid acquisition detection.
+///  - Behavior parity to Blink's WTF::RefCounted, whose count starts from one.
+///    And start-from-one ref count is a step to merge WTF::RefCounted into
+///    base::RefCounted.
+///
 #define REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE()                 \
   static constexpr ::base::cef_subtle::StartRefCountFromOneTag \
       kRefCountPreference = ::base::cef_subtle::kStartRefCountFromOneTag
@@ -343,6 +319,10 @@ using ScopedAllowCrossThreadRefCountAccess =
 template <class T, typename Traits>
 class RefCounted;
 
+///
+/// Default traits for RefCounted<T>.  Deletes the object when its ref count
+/// reaches 0. Overload to delete it on a different thread etc.
+///
 template <typename T>
 struct DefaultRefCountedTraits {
   static void Destruct(const T* x) {
@@ -350,6 +330,34 @@ struct DefaultRefCountedTraits {
   }
 };
 
+///
+/// A base class for reference counted classes. Otherwise, known as a cheap
+/// knock-off of WebKit's RefCounted<T> class. To use this, just extend your
+/// class from it like so:
+///
+/// <pre>
+///   class MyFoo : public base::RefCounted<MyFoo> {
+///    ...
+///    private:
+///     friend class base::RefCounted<MyFoo>;
+///     ~MyFoo();
+///   };
+/// </pre>
+///
+/// Usage Notes:
+/// 1. You should always make your destructor non-public, to avoid any code
+///    deleting the object accidentally while there are references to it.
+/// 2. You should always make the ref-counted base class a friend of your class,
+///    so that it can access the destructor.
+///
+/// The ref count manipulation to RefCounted is NOT thread safe and has DCHECKs
+/// to trap unsafe cross thread usage. A subclass instance of RefCounted can be
+/// passed to another execution thread only when its ref count is 1. If the ref
+/// count is more than 1, the RefCounted class verifies the ref updates are made
+/// on the same execution thread as the previous ones. The subclass can also
+/// manually call IsOnValidThread to trap other non-thread-safe accesses; see
+/// the documentation for that method.
+///
 template <class T, typename Traits = DefaultRefCountedTraits<T>>
 class RefCounted : public cef_subtle::RefCountedBase {
  public:
@@ -389,8 +397,10 @@ class RefCounted : public cef_subtle::RefCountedBase {
 template <class T, typename Traits>
 class RefCountedThreadSafe;
 
-// Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
-// count reaches 0.  Overload to delete it on a different thread etc.
+///
+/// Default traits for RefCountedThreadSafe<T>. Deletes the object when its ref
+/// count reaches 0. Overload to delete it on a different thread etc.
+///
 template <typename T>
 struct DefaultRefCountedThreadSafeTraits {
   static void Destruct(const T* x) {
@@ -402,21 +412,26 @@ struct DefaultRefCountedThreadSafeTraits {
   }
 };
 
-//
-// A thread-safe variant of RefCounted<T>
-//
-//   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
-//    ...
-//   };
-//
-// If you're using the default trait, then you should add compile time
-// asserts that no one else is deleting your object.  i.e.
-//    private:
-//     friend class base::RefCountedThreadSafe<MyFoo>;
-//     ~MyFoo();
-//
-// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
-// too. See the comment above the RefCounted definition for details.
+///
+/// A thread-safe variant of RefCounted<T>
+///
+/// <pre>
+///   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
+///    ...
+///   };
+/// </pre>
+///
+/// If you're using the default trait, then you should add compile time
+/// asserts that no one else is deleting your object.  i.e.
+/// <pre>
+///    private:
+///     friend class base::RefCountedThreadSafe<MyFoo>;
+///     ~MyFoo();
+/// </pre>
+///
+/// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
+/// too. See the comment above the RefCounted definition for details.
+///
 template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T>>
 class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
  public:
@@ -457,10 +472,10 @@ class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
   }
 };
 
-//
-// A thread-safe wrapper for some piece of data so we can place other
-// things in scoped_refptrs<>.
-//
+///
+/// A thread-safe wrapper for some piece of data so we can place other
+/// things in scoped_refptrs<>.
+///
 template <typename T>
 class RefCountedData
     : public base::RefCountedThreadSafe<base::RefCountedData<T>> {
@@ -469,7 +484,7 @@ class RefCountedData
   RefCountedData(const T& in_value) : data(in_value) {}
   RefCountedData(T&& in_value) : data(std::move(in_value)) {}
   template <typename... Args>
-  explicit RefCountedData(in_place_t, Args&&... args)
+  explicit RefCountedData(std::in_place_t, Args&&... args)
       : data(std::forward<Args>(args)...) {}
 
   T data;

include/base/cef_scoped_refptr.h

@@ -46,7 +46,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
 
 template <class T>
@@ -143,68 +142,76 @@ scoped_refptr<T> WrapRefCounted(T* t) {
 
 }  // namespace base
 
-//
-// A smart pointer class for reference counted objects.  Use this class instead
-// of calling AddRef and Release manually on a reference counted object to
-// avoid common memory leaks caused by forgetting to Release an object
-// reference.  Sample usage:
-//
-//   class MyFoo : public RefCounted<MyFoo> {
-//    ...
-//    private:
-//     friend class RefCounted<MyFoo>;  // Allow destruction by RefCounted<>.
-//     ~MyFoo();                        // Destructor must be private/protected.
-//   };
-//
-//   void some_function() {
-//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
-//     foo->Method(param);
-//     // |foo| is released when this function returns
-//   }
-//
-//   void some_other_function() {
-//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
-//     ...
-//     foo.reset();  // explicitly releases |foo|
-//     ...
-//     if (foo)
-//       foo->Method(param);
-//   }
-//
-// The above examples show how scoped_refptr<T> acts like a pointer to T.
-// Given two scoped_refptr<T> classes, it is also possible to exchange
-// references between the two objects, like so:
-//
-//   {
-//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b.swap(a);
-//     // now, |b| references the MyFoo object, and |a| references nullptr.
-//   }
-//
-// To make both |a| and |b| in the above example reference the same MyFoo
-// object, simply use the assignment operator:
-//
-//   {
-//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b = a;
-//     // now, |a| and |b| each own a reference to the same MyFoo object.
-//   }
-//
-// Also see Chromium's ownership and calling conventions:
-// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions
-// Specifically:
-//   If the function (at least sometimes) takes a ref on a refcounted object,
-//   declare the param as scoped_refptr<T>. The caller can decide whether it
-//   wishes to transfer ownership (by calling std::move(t) when passing t) or
-//   retain its ref (by simply passing t directly).
-//   In other words, use scoped_refptr like you would a std::unique_ptr except
-//   in the odd case where it's required to hold on to a ref while handing one
-//   to another component (if a component merely needs to use t on the stack
-//   without keeping a ref: pass t as a raw T*).
+///
+/// A smart pointer class for reference counted objects.  Use this class instead
+/// of calling AddRef and Release manually on a reference counted object to
+/// avoid common memory leaks caused by forgetting to Release an object
+/// reference. Sample usage:
+///
+/// <pre>
+///   class MyFoo : public RefCounted<MyFoo> {
+///    ...
+///    private:
+///     friend class RefCounted<MyFoo>;  // Allow destruction by RefCounted<>.
+///     ~MyFoo();                        // Destructor must be
+///     private/protected.
+///   };
+///
+///   void some_function() {
+///     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+///     foo->Method(param);
+///     // |foo| is released when this function returns
+///   }
+///
+///   void some_other_function() {
+///     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+///     ...
+///     foo.reset();  // explicitly releases |foo|
+///     ...
+///     if (foo)
+///       foo->Method(param);
+///   }
+/// </pre>
+///
+/// The above examples show how scoped_refptr<T> acts like a pointer to T.
+/// Given two scoped_refptr<T> classes, it is also possible to exchange
+/// references between the two objects, like so:
+///
+/// <pre>
+///   {
+///     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+///     scoped_refptr<MyFoo> b;
+///
+///     b.swap(a);
+///     // now, |b| references the MyFoo object, and |a| references nullptr.
+///   }
+/// </pre>
+///
+/// To make both |a| and |b| in the above example reference the same MyFoo
+/// object, simply use the assignment operator:
+///
+/// <pre>
+///   {
+///     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+///     scoped_refptr<MyFoo> b;
+///
+///     b = a;
+///     // now, |a| and |b| each own a reference to the same MyFoo object.
+///   }
+/// </pre>
+///
+/// Also see Chromium's ownership and calling conventions:
+/// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions
+/// Specifically:
+///   If the function (at least sometimes) takes a ref on a refcounted object,
+///   declare the param as scoped_refptr<T>. The caller can decide whether it
+///   wishes to transfer ownership (by calling std::move(t) when passing t) or
+///   retain its ref (by simply passing t directly).
+///   In other words, use scoped_refptr like you would a std::unique_ptr except
+///   in the odd case where it's required to hold on to a ref while handing one
+///   to another component (if a component merely needs to use t on the stack
+///   without keeping a ref: pass t as a raw T*).
+///
 template <class T>
 class TRIVIAL_ABI scoped_refptr {
  public:
@@ -222,8 +229,9 @@ class TRIVIAL_ABI scoped_refptr {
   // should move or copy construct from an existing scoped_refptr<T> to the
   // ref-counted object.
   scoped_refptr(T* p) : ptr_(p) {
-    if (ptr_)
+    if (ptr_) {
       AddRef(ptr_);
+    }
   }
 
   // Copy constructor. This is required in addition to the copy conversion
@@ -254,8 +262,9 @@ class TRIVIAL_ABI scoped_refptr {
                   "It's unsafe to override the ref count preference."
                   " Please remove REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE"
                   " from subclasses.");
-    if (ptr_)
+    if (ptr_) {
       Release(ptr_);
+    }
   }
 
   T* get() const { return ptr_; }
@@ -289,7 +298,7 @@ class TRIVIAL_ABI scoped_refptr {
 
   // Returns the owned pointer (if any), releasing ownership to the caller. The
   // caller is responsible for managing the lifetime of the reference.
-  T* release() WARN_UNUSED_RESULT;
+  [[nodiscard]] T* release();
 
   void swap(scoped_refptr& r) noexcept { std::swap(ptr_, r.ptr_); }
 

include/base/cef_scoped_typeref_mac.h

@@ -28,40 +28,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// ScopedTypeRef<> is patterned after std::unique_ptr<>, but maintains ownership
-// of a reference to any type that is maintained by Retain and Release methods.
-//
-// The Traits structure must provide the Retain and Release methods for type T.
-// A default ScopedTypeRefTraits is used but not defined, and should be defined
-// for each type to use this interface. For example, an appropriate definition
-// of ScopedTypeRefTraits for CGLContextObj would be:
-//
-//   template<>
-//   struct ScopedTypeRefTraits<CGLContextObj> {
-//     static CGLContextObj InvalidValue() { return nullptr; }
-//     static CGLContextObj Retain(CGLContextObj object) {
-//       CGLContextRetain(object);
-//       return object;
-//     }
-//     static void Release(CGLContextObj object) { CGLContextRelease(object); }
-//   };
-//
-// For the many types that have pass-by-pointer create functions, the function
-// InitializeInto() is provided to allow direct initialization and assumption
-// of ownership of the object. For example, continuing to use the above
-// CGLContextObj specialization:
-//
-//   base::ScopedTypeRef<CGLContextObj> context;
-//   CGLCreateContext(pixel_format, share_group, context.InitializeInto());
-//
-// For initialization with an existing object, the caller may specify whether
-// the ScopedTypeRef<> being initialized is assuming the caller's existing
-// ownership of the object (and should not call Retain in initialization) or if
-// it should not assume this ownership and must create its own (by calling
-// Retain in initialization). This behavior is based on the |policy| parameter,
-// with |ASSUME| for the former and |RETAIN| for the latter. The default policy
-// is to |ASSUME|.
-
 #ifndef CEF_INCLUDE_BASE_CEF_SCOPED_TYPEREF_MAC_H_
 #define CEF_INCLUDE_BASE_CEF_SCOPED_TYPEREF_MAC_H_
 #pragma once
@@ -74,16 +40,55 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
 #include "include/base/internal/cef_scoped_policy.h"
 
 namespace base {
 
-template<typename T>
+template <typename T>
 struct ScopedTypeRefTraits;
 
-template<typename T, typename Traits = ScopedTypeRefTraits<T>>
+///
+/// ScopedTypeRef<> is patterned after std::unique_ptr<>, but maintains
+/// ownership of a reference to any type that is maintained by Retain and
+/// Release methods.
+///
+/// The Traits structure must provide the Retain and Release methods for type T.
+/// A default ScopedTypeRefTraits is used but not defined, and should be defined
+/// for each type to use this interface. For example, an appropriate definition
+/// of ScopedTypeRefTraits for CGLContextObj would be:
+///
+/// <pre>
+///   template<>
+///   struct ScopedTypeRefTraits<CGLContextObj> {
+///     static CGLContextObj InvalidValue() { return nullptr; }
+///     static CGLContextObj Retain(CGLContextObj object) {
+///       CGLContextRetain(object);
+///       return object;
+///     }
+///     static void Release(CGLContextObj object) { CGLContextRelease(object); }
+///   };
+/// </pre>
+///
+/// For the many types that have pass-by-pointer create functions, the function
+/// InitializeInto() is provided to allow direct initialization and assumption
+/// of ownership of the object. For example, continuing to use the above
+/// CGLContextObj specialization:
+///
+/// <pre>
+///   base::ScopedTypeRef<CGLContextObj> context;
+///   CGLCreateContext(pixel_format, share_group, context.InitializeInto());
+/// </pre>
+///
+/// For initialization with an existing object, the caller may specify whether
+/// the ScopedTypeRef<> being initialized is assuming the caller's existing
+/// ownership of the object (and should not call Retain in initialization) or if
+/// it should not assume this ownership and must create its own (by calling
+/// Retain in initialization). This behavior is based on the |policy| parameter,
+/// with |ASSUME| for the former and |RETAIN| for the latter. The default policy
+/// is to |ASSUME|.
+///
+template <typename T, typename Traits = ScopedTypeRefTraits<T>>
 class ScopedTypeRef {
  public:
   using element_type = T;
@@ -92,22 +97,24 @@ class ScopedTypeRef {
       element_type object = Traits::InvalidValue(),
       base::scoped_policy::OwnershipPolicy policy = base::scoped_policy::ASSUME)
       : object_(object) {
-    if (object_ && policy == base::scoped_policy::RETAIN)
+    if (object_ && policy == base::scoped_policy::RETAIN) {
       object_ = Traits::Retain(object_);
+    }
   }
 
-  ScopedTypeRef(const ScopedTypeRef<T, Traits>& that)
-      : object_(that.object_) {
-    if (object_)
+  ScopedTypeRef(const ScopedTypeRef<T, Traits>& that) : object_(that.object_) {
+    if (object_) {
       object_ = Traits::Retain(object_);
+    }
   }
 
   // This allows passing an object to a function that takes its superclass.
   template <typename R, typename RTraits>
   explicit ScopedTypeRef(const ScopedTypeRef<R, RTraits>& that_as_subclass)
       : object_(that_as_subclass.get()) {
-    if (object_)
+    if (object_) {
       object_ = Traits::Retain(object_);
+    }
   }
 
   ScopedTypeRef(ScopedTypeRef<T, Traits>&& that) : object_(that.object_) {
@@ -115,8 +122,9 @@ class ScopedTypeRef {
   }
 
   ~ScopedTypeRef() {
-    if (object_)
+    if (object_) {
       Traits::Release(object_);
+    }
   }
 
   ScopedTypeRef& operator=(const ScopedTypeRef<T, Traits>& that) {
@@ -127,7 +135,7 @@ class ScopedTypeRef {
   // This is to be used only to take ownership of objects that are created
   // by pass-by-pointer create functions. To enforce this, require that the
   // object be reset to NULL before this may be used.
-  element_type* InitializeInto() WARN_UNUSED_RESULT {
+  [[nodiscard]] element_type* InitializeInto() {
     DCHECK(!object_);
     return &object_;
   }
@@ -139,10 +147,12 @@ class ScopedTypeRef {
   void reset(element_type object = Traits::InvalidValue(),
              base::scoped_policy::OwnershipPolicy policy =
                  base::scoped_policy::ASSUME) {
-    if (object && policy == base::scoped_policy::RETAIN)
+    if (object && policy == base::scoped_policy::RETAIN) {
       object = Traits::Retain(object);
-    if (object_)
+    }
+    if (object_) {
       Traits::Release(object_);
+    }
     object_ = object;
   }
 
@@ -163,7 +173,7 @@ class ScopedTypeRef {
   // ScopedTypeRef<>::release() is like std::unique_ptr<>::release.  It is NOT
   // a wrapper for Release().  To force a ScopedTypeRef<> object to call
   // Release(), use ScopedTypeRef<>::reset().
-  element_type release() WARN_UNUSED_RESULT {
+  [[nodiscard]] element_type release() {
     element_type temp = object_;
     object_ = Traits::InvalidValue();
     return temp;

include/base/cef_template_util.h

@@ -1,414 +0,0 @@
-// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
-// Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
-#define CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
-#pragma once
-
-#if defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-#include "base/template_util.h"
-#else  // !USING_CHROMIUM_INCLUDES
-// The following is substantially similar to the Chromium implementation.
-// If the Chromium implementation diverges the below implementation should be
-// updated to match.
-
-#include <stddef.h>
-#include <iosfwd>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "include/base/cef_build.h"
-
-// Some versions of libstdc++ have partial support for type_traits, but misses
-// a smaller subset while removing some of the older non-standard stuff. Assume
-// that all versions below 5.0 fall in this category, along with one 5.0
-// experimental release. Test for this by consulting compiler major version,
-// the only reliable option available, so theoretically this could fail should
-// you attempt to mix an earlier version of libstdc++ with >= GCC5. But
-// that's unlikely to work out, especially as GCC5 changed ABI.
-#define CR_GLIBCXX_5_0_0 20150123
-#if (defined(__GNUC__) && __GNUC__ < 5) || \
-    (defined(__GLIBCXX__) && __GLIBCXX__ == CR_GLIBCXX_5_0_0)
-#define CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-#endif
-
-// This hacks around using gcc with libc++ which has some incompatibilies.
-// - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that works with older
-// gcc versions.
-#if !defined(__clang__) && defined(_LIBCPP_VERSION)
-#define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#endif
-
-namespace base {
-
-template <class T> struct is_non_const_reference : std::false_type {};
-template <class T> struct is_non_const_reference<T&> : std::true_type {};
-template <class T> struct is_non_const_reference<const T&> : std::false_type {};
-
-namespace internal {
-
-// Implementation detail of base::void_t below.
-template <typename...>
-struct make_void {
-  using type = void;
-};
-
-}  // namespace internal
-
-// base::void_t is an implementation of std::void_t from C++17.
-//
-// We use |base::internal::make_void| as a helper struct to avoid a C++14
-// defect:
-//   http://en.cppreference.com/w/cpp/types/void_t
-//   http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
-template <typename... Ts>
-using void_t = typename ::base::internal::make_void<Ts...>::type;
-
-namespace internal {
-
-// Uses expression SFINAE to detect whether using operator<< would work.
-template <typename T, typename = void>
-struct SupportsOstreamOperator : std::false_type {};
-template <typename T>
-struct SupportsOstreamOperator<T,
-                               decltype(void(std::declval<std::ostream&>()
-                                             << std::declval<T>()))>
-    : std::true_type {};
-
-template <typename T, typename = void>
-struct SupportsToString : std::false_type {};
-template <typename T>
-struct SupportsToString<T, decltype(void(std::declval<T>().ToString()))>
-    : std::true_type {};
-
-// Used to detect whether the given type is an iterator.  This is normally used
-// with std::enable_if to provide disambiguation for functions that take
-// templatzed iterators as input.
-template <typename T, typename = void>
-struct is_iterator : std::false_type {};
-
-template <typename T>
-struct is_iterator<T,
-                   void_t<typename std::iterator_traits<T>::iterator_category>>
-    : std::true_type {};
-
-// Helper to express preferences in an overload set. If more than one overload
-// are available for a given set of parameters the overload with the higher
-// priority will be chosen.
-template <size_t I>
-struct priority_tag : priority_tag<I - 1> {};
-
-template <>
-struct priority_tag<0> {};
-
-}  // namespace internal
-
-// is_trivially_copyable is especially hard to get right.
-// - Older versions of libstdc++ will fail to have it like they do for other
-//   type traits. This has become a subset of the second point, but used to be
-//   handled independently.
-// - An experimental release of gcc includes most of type_traits but misses
-//   is_trivially_copyable, so we still have to avoid using libstdc++ in this
-//   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
-// - When compiling libc++ from before r239653, with a gcc compiler, the
-//   std::is_trivially_copyable can fail. So we need to work around that by not
-//   using the one in libc++ in this case. This is covered by the
-//   CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX define, and is discussed in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 where they point out that
-//   in libc++'s commit r239653 this is fixed by libc++ checking for gcc 5.1.
-// - In both of the above cases we are using the gcc compiler. When defining
-//   this ourselves on compiler intrinsics, the __is_trivially_copyable()
-//   intrinsic is not available on gcc before version 5.1 (see the discussion in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 again), so we must check for
-//   that version.
-// - When __is_trivially_copyable() is not available because we are on gcc older
-//   than 5.1, we need to fall back to something, so we use __has_trivial_copy()
-//   instead based on what was done one-off in bit_cast() previously.
-
-// TODO(crbug.com/554293): Remove this when all platforms have this in the std
-// namespace and it works with gcc as needed.
-#if defined(CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX) || \
-    defined(CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX)
-template <typename T>
-struct is_trivially_copyable {
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that does this for
-// us.
-#if _GNUC_VER >= 501
-  static constexpr bool value = __is_trivially_copyable(T);
-#else
-  static constexpr bool value =
-      __has_trivial_copy(T) && __has_trivial_destructor(T);
-#endif
-};
-#else
-template <class T>
-using is_trivially_copyable = std::is_trivially_copyable<T>;
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
-// Workaround for g++7 and earlier family.
-// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654, without this
-// Optional<std::vector<T>> where T is non-copyable causes a compile error.
-// As we know it is not trivially copy constructible, explicitly declare so.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_trivially_copy_constructible<T> {};
-
-template <typename... T>
-struct is_trivially_copy_constructible<std::vector<T...>> : std::false_type {};
-#else
-// Otherwise use std::is_trivially_copy_constructible as is.
-template <typename T>
-using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
-#endif
-
-// base::in_place_t is an implementation of std::in_place_t from
-// C++17. A tag type used to request in-place construction in template vararg
-// constructors.
-
-// Specification:
-// https://en.cppreference.com/w/cpp/utility/in_place
-struct in_place_t {};
-constexpr in_place_t in_place = {};
-
-// base::in_place_type_t is an implementation of std::in_place_type_t from
-// C++17. A tag type used for in-place construction when the type to construct
-// needs to be specified, such as with base::unique_any, designed to be a
-// drop-in replacement.
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/in_place
-template <typename T>
-struct in_place_type_t {};
-
-template <typename T>
-struct is_in_place_type_t {
-  static constexpr bool value = false;
-};
-
-template <typename... Ts>
-struct is_in_place_type_t<in_place_type_t<Ts...>> {
-  static constexpr bool value = true;
-};
-
-// C++14 implementation of C++17's std::bool_constant.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/integral_constant
-// Specification: https://wg21.link/meta.type.synop
-template <bool B>
-using bool_constant = std::integral_constant<bool, B>;
-
-// C++14 implementation of C++17's std::conjunction.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/conjunction
-// Specification: https://wg21.link/meta.logical#1.itemdecl:1
-template <typename...>
-struct conjunction : std::true_type {};
-
-template <typename B1>
-struct conjunction<B1> : B1 {};
-
-template <typename B1, typename... Bn>
-struct conjunction<B1, Bn...>
-    : std::conditional_t<static_cast<bool>(B1::value), conjunction<Bn...>, B1> {
-};
-
-// C++14 implementation of C++17's std::disjunction.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/disjunction
-// Specification: https://wg21.link/meta.logical#itemdecl:2
-template <typename...>
-struct disjunction : std::false_type {};
-
-template <typename B1>
-struct disjunction<B1> : B1 {};
-
-template <typename B1, typename... Bn>
-struct disjunction<B1, Bn...>
-    : std::conditional_t<static_cast<bool>(B1::value), B1, disjunction<Bn...>> {
-};
-
-// C++14 implementation of C++17's std::negation.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/negation
-// Specification: https://wg21.link/meta.logical#itemdecl:3
-template <typename B>
-struct negation : bool_constant<!static_cast<bool>(B::value)> {};
-
-// Implementation of C++17's invoke_result.
-//
-// This implementation adds references to `Functor` and `Args` to work around
-// some quirks of std::result_of. See the #Notes section of [1] for details.
-//
-// References:
-// [1] https://en.cppreference.com/w/cpp/types/result_of
-// [2] https://wg21.link/meta.trans.other#lib:invoke_result
-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
-template <typename Functor, typename... Args>
-using invoke_result = std::invoke_result<Functor, Args...>;
-#else
-template <typename Functor, typename... Args>
-using invoke_result = std::result_of<Functor && (Args && ...)>;
-#endif
-
-// Implementation of C++17's std::invoke_result_t.
-//
-// Reference: https://wg21.link/meta.type.synop#lib:invoke_result_t
-template <typename Functor, typename... Args>
-using invoke_result_t = typename invoke_result<Functor, Args...>::type;
-
-namespace internal {
-
-// Base case, `InvokeResult` does not have a nested type member. This means `F`
-// could not be invoked with `Args...` and thus is not invocable.
-template <typename InvokeResult, typename R, typename = void>
-struct IsInvocableImpl : std::false_type {};
-
-// Happy case, `InvokeResult` does have a nested type member. Now check whether
-// `InvokeResult::type` is convertible to `R`. Short circuit in case
-// `std::is_void<R>`.
-template <typename InvokeResult, typename R>
-struct IsInvocableImpl<InvokeResult, R, void_t<typename InvokeResult::type>>
-    : disjunction<std::is_void<R>,
-                  std::is_convertible<typename InvokeResult::type, R>> {};
-
-}  // namespace internal
-
-// Implementation of C++17's std::is_invocable_r.
-//
-// Returns whether `F` can be invoked with `Args...` and the result is
-// convertible to `R`.
-//
-// Reference: https://wg21.link/meta.rel#lib:is_invocable_r
-template <typename R, typename F, typename... Args>
-struct is_invocable_r
-    : internal::IsInvocableImpl<invoke_result<F, Args...>, R> {};
-
-// Implementation of C++17's std::is_invocable.
-//
-// Returns whether `F` can be invoked with `Args...`.
-//
-// Reference: https://wg21.link/meta.rel#lib:is_invocable
-template <typename F, typename... Args>
-struct is_invocable : is_invocable_r<void, F, Args...> {};
-
-namespace internal {
-
-// The indirection with std::is_enum<T> is required, because instantiating
-// std::underlying_type_t<T> when T is not an enum is UB prior to C++20.
-template <typename T, bool = std::is_enum<T>::value>
-struct IsScopedEnumImpl : std::false_type {};
-
-template <typename T>
-struct IsScopedEnumImpl<T, /*std::is_enum<T>::value=*/true>
-    : negation<std::is_convertible<T, std::underlying_type_t<T>>> {};
-
-}  // namespace internal
-
-// Implementation of C++23's std::is_scoped_enum
-//
-// Reference: https://en.cppreference.com/w/cpp/types/is_scoped_enum
-template <typename T>
-struct is_scoped_enum : internal::IsScopedEnumImpl<T> {};
-
-// Implementation of C++20's std::remove_cvref.
-//
-// References:
-// - https://en.cppreference.com/w/cpp/types/remove_cvref
-// - https://wg21.link/meta.trans.other#lib:remove_cvref
-template <typename T>
-struct remove_cvref {
-  using type = std::remove_cv_t<std::remove_reference_t<T>>;
-};
-
-// Implementation of C++20's std::remove_cvref_t.
-//
-// References:
-// - https://en.cppreference.com/w/cpp/types/remove_cvref
-// - https://wg21.link/meta.type.synop#lib:remove_cvref_t
-template <typename T>
-using remove_cvref_t = typename remove_cvref<T>::type;
-
-// Simplified implementation of C++20's std::iter_value_t.
-// As opposed to std::iter_value_t, this implementation does not restrict
-// the type of `Iter` and does not consider specializations of
-// `indirectly_readable_traits`.
-//
-// Reference: https://wg21.link/readable.traits#2
-template <typename Iter>
-using iter_value_t =
-    typename std::iterator_traits<remove_cvref_t<Iter>>::value_type;
-
-// Simplified implementation of C++20's std::iter_reference_t.
-// As opposed to std::iter_reference_t, this implementation does not restrict
-// the type of `Iter`.
-//
-// Reference: https://wg21.link/iterator.synopsis#:~:text=iter_reference_t
-template <typename Iter>
-using iter_reference_t = decltype(*std::declval<Iter&>());
-
-// Simplified implementation of C++20's std::indirect_result_t. As opposed to
-// std::indirect_result_t, this implementation does not restrict the type of
-// `Func` and `Iters`.
-//
-// Reference: https://wg21.link/iterator.synopsis#:~:text=indirect_result_t
-template <typename Func, typename... Iters>
-using indirect_result_t = invoke_result_t<Func, iter_reference_t<Iters>...>;
-
-// Simplified implementation of C++20's std::projected. As opposed to
-// std::projected, this implementation does not explicitly restrict the type of
-// `Iter` and `Proj`, but rather does so implicitly by requiring
-// `indirect_result_t<Proj, Iter>` is a valid type. This is required for SFINAE
-// friendliness.
-//
-// Reference: https://wg21.link/projected
-template <typename Iter,
-          typename Proj,
-          typename IndirectResultT = indirect_result_t<Proj, Iter>>
-struct projected {
-  using value_type = remove_cvref_t<IndirectResultT>;
-
-  IndirectResultT operator*() const;  // not defined
-};
-
-}  // namespace base
-
-#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_

include/base/cef_thread_checker.h

@@ -43,10 +43,12 @@
 #include "include/base/cef_logging.h"
 #include "include/base/internal/cef_thread_checker_impl.h"
 
-// Apart from debug builds, we also enable the thread checker in
-// builds with DCHECK_ALWAYS_ON so that trybots and waterfall bots
-// with this define will get the same level of thread checking as
-// debug bots.
+///
+/// Apart from debug builds, we also enable the thread checker in
+/// builds with DCHECK_ALWAYS_ON so that trybots and waterfall bots
+/// with this define will get the same level of thread checking as
+/// debug bots.
+///
 #if DCHECK_IS_ON()
 #define ENABLE_THREAD_CHECKER 1
 #else
@@ -57,10 +59,12 @@ namespace base {
 
 namespace cef_internal {
 
-// Do nothing implementation, for use in release mode.
-//
-// Note: You should almost always use the ThreadChecker class to get the
-// right version for your build configuration.
+///
+/// Do nothing implementation, for use in release mode.
+///
+/// Note: You should almost always use the ThreadChecker class to get the
+/// right version for your build configuration.
+///
 class ThreadCheckerDoNothing {
  public:
   bool CalledOnValidThread() const { return true; }
@@ -70,37 +74,42 @@ class ThreadCheckerDoNothing {
 
 }  // namespace cef_internal
 
-// ThreadChecker is a helper class used to help verify that some methods of a
-// class are called from the same thread. It provides identical functionality to
-// base::NonThreadSafe, but it is meant to be held as a member variable, rather
-// than inherited from base::NonThreadSafe.
-//
-// While inheriting from base::NonThreadSafe may give a clear indication about
-// the thread-safety of a class, it may also lead to violations of the style
-// guide with regard to multiple inheritance. The choice between having a
-// ThreadChecker member and inheriting from base::NonThreadSafe should be based
-// on whether:
-//  - Derived classes need to know the thread they belong to, as opposed to
-//    having that functionality fully encapsulated in the base class.
-//  - Derived classes should be able to reassign the base class to another
-//    thread, via DetachFromThread.
-//
-// If neither of these are true, then having a ThreadChecker member and calling
-// CalledOnValidThread is the preferable solution.
-//
-// Example:
-// class MyClass {
-//  public:
-//   void Foo() {
-//     DCHECK(thread_checker_.CalledOnValidThread());
-//     ... (do stuff) ...
-//   }
-//
-//  private:
-//   ThreadChecker thread_checker_;
-// }
-//
-// In Release mode, CalledOnValidThread will always return true.
+///
+/// ThreadChecker is a helper class used to help verify that some methods of a
+/// class are called from the same thread. It provides identical functionality
+/// to base::NonThreadSafe, but it is meant to be held as a member variable,
+/// rather than inherited from base::NonThreadSafe.
+///
+/// While inheriting from base::NonThreadSafe may give a clear indication about
+/// the thread-safety of a class, it may also lead to violations of the style
+/// guide with regard to multiple inheritance. The choice between having a
+/// ThreadChecker member and inheriting from base::NonThreadSafe should be based
+/// on whether:
+///  - Derived classes need to know the thread they belong to, as opposed to
+///    having that functionality fully encapsulated in the base class.
+///  - Derived classes should be able to reassign the base class to another
+///    thread, via DetachFromThread.
+///
+/// If neither of these are true, then having a ThreadChecker member and calling
+/// CalledOnValidThread is the preferable solution.
+///
+/// Example:
+///
+/// <pre>
+///   class MyClass {
+///    public:
+///     void Foo() {
+///       DCHECK(thread_checker_.CalledOnValidThread());
+///       ... (do stuff) ...
+///     }
+///
+///    private:
+///     ThreadChecker thread_checker_;
+///   }
+/// </pre>
+///
+/// In Release mode, CalledOnValidThread will always return true.
+///
 #if ENABLE_THREAD_CHECKER
 class ThreadChecker : public cef_internal::ThreadCheckerImpl {};
 #else

include/base/cef_trace_event.h

@@ -29,111 +29,125 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ///
-// Trace events are for tracking application performance and resource usage.
-// Macros are provided to track:
-//    Begin and end of function calls
-//    Counters
-//
-// Events are issued against categories. Whereas LOG's categories are statically
-// defined, TRACE categories are created implicitly with a string. For example:
-//   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
-//
-// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
-//   TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
-//   doSomethingCostly()
-//   TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
-// Note: Our tools can't always determine the correct BEGIN/END pairs unless
-// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
-// need them to be in separate scopes.
-//
-// A common use case is to trace entire function scopes. This issues a trace
-// BEGIN and END automatically:
-//   void doSomethingCostly() {
-//     TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
-//     ...
-//   }
-//
-// Additional parameters can be associated with an event:
-//   void doSomethingCostly2(int howMuch) {
-//     TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
-//         "howMuch", howMuch);
-//     ...
-//   }
-//
-// The trace system will automatically add to this information the current
-// process id, thread id, and a timestamp in microseconds.
-//
-// To trace an asynchronous procedure such as an IPC send/receive, use
-// ASYNC_BEGIN and ASYNC_END:
-//   [single threaded sender code]
-//     static int send_count = 0;
-//     ++send_count;
-//     TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
-//     Send(new MyMessage(send_count));
-//   [receive code]
-//     void OnMyMessage(send_count) {
-//       TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
-//     }
-// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
-// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
-// Pointers can be used for the ID parameter, and they will be mangled
-// internally so that the same pointer on two different processes will not
-// match. For example:
-//   class MyTracedClass {
-//    public:
-//     MyTracedClass() {
-//       TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
-//     }
-//     ~MyTracedClass() {
-//       TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
-//     }
-//   }
-//
-// The trace event also supports counters, which is a way to track a quantity
-// as it varies over time. Counters are created with the following macro:
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
-//
-// Counters are process-specific. The macro itself can be issued from any
-// thread, however.
-//
-// Sometimes, you want to track two counters at once. You can do this with two
-// counter macros:
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
-//   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
-// Or you can do it with a combined macro:
-//   TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
-//       "bytesPinned", g_myCounterValue[0],
-//       "bytesAllocated", g_myCounterValue[1]);
-// This indicates to the tracing UI that these counters should be displayed
-// in a single graph, as a summed area chart.
-//
-// Since counters are in a global namespace, you may want to disembiguate with a
-// unique ID, by using the TRACE_COUNTER_ID* variations.
-//
-// By default, trace collection is compiled in, but turned off at runtime.
-// Collecting trace data is the responsibility of the embedding application. In
-// CEF's case, calling BeginTracing will turn on tracing on all active
-// processes.
-//
-//
-// Memory scoping note:
-// Tracing copies the pointers, not the string content, of the strings passed
-// in for category, name, and arg_names.  Thus, the following code will cause
-// problems:
-//     char* str = strdup("impprtantName");
-//     TRACE_EVENT_INSTANT0("SUBSYSTEM", str);  // BAD!
-//     free(str);                   // Trace system now has dangling pointer
-//
-// To avoid this issue with the |name| and |arg_name| parameters, use the
-// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime
-// overhead.
-// Notes: The category must always be in a long-lived char* (i.e. static const).
-//        The |arg_values|, when used, are always deep copied with the _COPY
-//        macros.
-//
-//
-// Thread Safety:
-// All macros are thread safe and can be used from any process.
+/// \file
+/// Trace events are for tracking application performance and resource usage.
+/// Macros are provided to track:
+///    Begin and end of function calls
+///    Counters
+///
+/// Events are issued against categories. Whereas LOG's categories are
+/// statically defined, TRACE categories are created implicitly with a string.
+/// For example: <pre>
+///   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
+/// </pre>
+///
+/// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
+/// <pre>
+///   TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
+///   doSomethingCostly()
+///   TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
+/// </pre>
+/// Note: Our tools can't always determine the correct BEGIN/END pairs unless
+/// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
+/// need them to be in separate scopes.
+///
+/// A common use case is to trace entire function scopes. This issues a trace
+/// BEGIN and END automatically:
+/// <pre>
+///   void doSomethingCostly() {
+///     TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
+///     ...
+///   }
+/// </pre>
+///
+/// Additional parameters can be associated with an event:
+/// <pre>
+///   void doSomethingCostly2(int howMuch) {
+///     TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
+///         "howMuch", howMuch);
+///     ...
+///   }
+/// </pre>
+///
+/// The trace system will automatically add to this information the current
+/// process id, thread id, and a timestamp in microseconds.
+///
+/// To trace an asynchronous procedure such as an IPC send/receive, use
+/// ASYNC_BEGIN and ASYNC_END:
+/// <pre>
+///   [single threaded sender code]
+///     static int send_count = 0;
+///     ++send_count;
+///     TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
+///     Send(new MyMessage(send_count));
+///   [receive code]
+///     void OnMyMessage(send_count) {
+///       TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
+///     }
+/// </pre>
+/// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
+/// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
+/// Pointers can be used for the ID parameter, and they will be mangled
+/// internally so that the same pointer on two different processes will not
+/// match. For example:
+/// <pre>
+///   class MyTracedClass {
+///    public:
+///     MyTracedClass() {
+///       TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
+///     }
+///     ~MyTracedClass() {
+///       TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
+///     }
+///   }
+/// </pre>
+///
+/// The trace event also supports counters, which is a way to track a quantity
+/// as it varies over time. Counters are created with the following macro:
+/// <pre>
+///   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
+/// </pre>
+///
+/// Counters are process-specific. The macro itself can be issued from any
+/// thread, however.
+///
+/// Sometimes, you want to track two counters at once. You can do this with two
+/// counter macros:
+/// <pre>
+///   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
+///   TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
+/// </pre>
+/// Or you can do it with a combined macro:
+/// <pre>
+///   TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
+///       "bytesPinned", g_myCounterValue[0],
+///       "bytesAllocated", g_myCounterValue[1]);
+/// </pre>
+/// This indicates to the tracing UI that these counters should be displayed
+/// in a single graph, as a summed area chart.
+///
+/// Since counters are in a global namespace, you may want to disembiguate with
+/// a unique ID, by using the TRACE_COUNTER_ID* variations.
+///
+/// By default, trace collection is compiled in, but turned off at runtime.
+/// Collecting trace data is the responsibility of the embedding application. In
+/// CEF's case, calling BeginTracing will turn on tracing on all active
+/// processes.
+///
+///
+/// Memory scoping note:
+/// Tracing copies the pointers, not the string content, of the strings passed
+/// in for category, name, and arg_names.  Thus, the following code will cause
+/// problems:
+/// <pre>
+///     char* str = strdup("impprtantName");
+///     TRACE_EVENT_INSTANT0("SUBSYSTEM", str);  // BAD!
+///     free(str);                   // Trace system now has dangling pointer
+/// </pre>
+///
+///
+/// Thread Safety:
+/// All macros are thread safe and can be used from any process.
 ///
 
 #ifndef CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
@@ -141,7 +155,7 @@
 #pragma once
 
 #if defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
+/// When building CEF include the Chromium header directly.
 #include "base/trace_event/trace_event.h"
 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
@@ -150,20 +164,22 @@
 
 #include "include/internal/cef_trace_event_internal.h"
 
-// Records a pair of begin and end events called "name" for the current
-// scope, with 0, 1 or 2 associated arguments. If the category is not
-// enabled, then this does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-#define TRACE_EVENT0(category, name)                              \
-  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false); \
+///
+/// Records a pair of begin and end events called "name" for the current
+/// scope, with 0, 1 or 2 associated arguments. If the category is not
+/// enabled, then this does nothing.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
+#define TRACE_EVENT0(category, name)                       \
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0); \
   CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
-#define TRACE_EVENT1(category, name, arg1_name, arg1_val)                     \
-  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
+#define TRACE_EVENT1(category, name, arg1_name, arg1_val)              \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0); \
   CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
 #define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
   cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name,        \
-                        arg2_val, false);                                      \
+                        arg2_val);                                             \
   CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
 
 // Implementation detail: trace event macros create temporary variable names.
@@ -179,228 +195,181 @@
   cef_trace_event::CefTraceEndOnScopeClose CEF_INTERNAL_TRACE_EVENT_UID( \
       profileScope)(category, name)
 
-// Records a single event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
+///
+/// Records a single event called "name" immediately, with 0, 1 or 2
+/// associated arguments. If the category is not enabled, then this
+/// does nothing.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
 #define TRACE_EVENT_INSTANT0(category, name) \
-  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
+  cef_trace_event_instant(category, name, NULL, 0, NULL, 0)
 #define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
+  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0)
 #define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
                              arg2_val)                                       \
   cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name,    \
-                          arg2_val, false)
-#define TRACE_EVENT_COPY_INSTANT0(category, name) \
-  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, true)
-#define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val,    \
-                                  arg2_name, arg2_val)                    \
-  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
-                          arg2_val, true)
+                          arg2_val)
 
-// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
+///
+/// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
+/// associated arguments. If the category is not enabled, then this
+/// does nothing.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
 #define TRACE_EVENT_BEGIN0(category, name) \
-  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
+  cef_trace_event_begin(category, name, NULL, 0, NULL, 0)
 #define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0)
 #define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
                            arg2_val)                                       \
   cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name,    \
-                        arg2_val, false)
-#define TRACE_EVENT_COPY_BEGIN0(category, name) \
-  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, true)
-#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val,    \
-                                arg2_name, arg2_val)                    \
-  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
-                        arg2_val, true)
+                        arg2_val)
 
-// Records a single END event for "name" immediately. If the category
-// is not enabled, then this does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
+///
+/// Records a single END event for "name" immediately. If the category
+/// is not enabled, then this does nothing.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
 #define TRACE_EVENT_END0(category, name) \
-  cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
+  cef_trace_event_end(category, name, NULL, 0, NULL, 0)
 #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
+  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0)
 #define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
                          arg2_val)                                       \
-  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name,    \
-                      arg2_val, false)
-#define TRACE_EVENT_COPY_END0(category, name) \
-  cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
-  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
-#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
-                              arg2_val)                                       \
-  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name,         \
-                      arg2_val, true)
+  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, arg2_val)
 
-// Records the value of a counter called "name" immediately. Value
-// must be representable as a 32 bit integer.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
+///
+/// Records the value of a counter called "name" immediately. Value
+/// must be representable as a 32 bit integer.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
 #define TRACE_COUNTER1(category, name, value) \
-  cef_trace_counter(category, name, NULL, value, NULL, 0, false)
-#define TRACE_COPY_COUNTER1(category, name, value) \
-  cef_trace_counter(category, name, NULL, value, NULL, 0, true)
+  cef_trace_counter(category, name, NULL, value, NULL, 0)
 
-// Records the values of a multi-parted counter called "name" immediately.
-// The UI will treat value1 and value2 as parts of a whole, displaying their
-// values as a stacked-bar chart.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
+///
+/// Records the values of a multi-parted counter called "name" immediately.
+/// The UI will treat value1 and value2 as parts of a whole, displaying their
+/// values as a stacked-bar chart.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+///
 #define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
                        value2_val)                                           \
   cef_trace_counter(category, name, value1_name, value1_val, value2_name,    \
-                    value2_val, false)
-#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val,      \
-                            value2_name, value2_val)                      \
-  cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
-                    value2_val, true)
+                    value2_val)
 
-// Records the value of a counter called "name" immediately. Value
-// must be representable as a 32 bit integer.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to disambiguate counters with the same name. It must either
-//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
-//   bits will be xored with a hash of the process ID so that the same pointer
-//   on two different processes will not collide.
+///
+/// Records the value of a counter called "name" immediately. Value
+/// must be representable as a 32 bit integer.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+/// - |id| is used to disambiguate counters with the same name. It must either
+///   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+///   bits will be xored with a hash of the process ID so that the same pointer
+///   on two different processes will not collide.
+///
 #define TRACE_COUNTER_ID1(category, name, id, value) \
-  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, false)
-#define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
-  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, true)
+  cef_trace_counter_id(category, name, id, NULL, value, NULL, 0)
 
-// Records the values of a multi-parted counter called "name" immediately.
-// The UI will treat value1 and value2 as parts of a whole, displaying their
-// values as a stacked-bar chart.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to disambiguate counters with the same name. It must either
-//   be a pointer or an integer value up to 64 bits. If it's a pointer, the
-//   bits will be xored with a hash of the process ID so that the same pointer
-//   on two different processes will not collide.
+///
+/// Records the values of a multi-parted counter called "name" immediately.
+/// The UI will treat value1 and value2 as parts of a whole, displaying their
+/// values as a stacked-bar chart.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+/// - |id| is used to disambiguate counters with the same name. It must either
+///   be a pointer or an integer value up to 64 bits. If it's a pointer, the
+///   bits will be xored with a hash of the process ID so that the same pointer
+///   on two different processes will not collide.
+///
 #define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
                           value2_name, value2_val)                     \
   cef_trace_counter_id(category, name, id, value1_name, value1_val,    \
-                       value2_name, value2_val, false)
-#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
-                               value2_name, value2_val)                     \
-  cef_trace_counter_id(category, name, id, value1_name, value1_val,         \
-                       value2_name, value2_val, true)
+                       value2_name, value2_val)
 
-// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
-// associated arguments. If the category is not enabled, then this
-// does nothing.
-// - category and name strings must have application lifetime (statics or
-//   literals). They may not include " chars.
-// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event.
-//   ASYNC events are considered to match if their category, name and id values
-//   all match. |id| must either be a pointer or an integer value up to 64
-//   bits. If it's a pointer, the bits will be xored with a hash of the process
-//   ID sothat the same pointer on two different processes will not collide.
-// An asynchronous operation can consist of multiple phases. The first phase is
-// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
-// ASYNC_STEP_BEGIN macros. When the operation completes, call ASYNC_END.
-// An async operation can span threads and processes, but all events in that
-// operation must use the same |name| and |id|. Each event can have its own
-// args.
+///
+/// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
+/// associated arguments. If the category is not enabled, then this
+/// does nothing.
+/// - category and name strings must have application lifetime (statics or
+///   literals). They may not include " chars.
+/// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event.
+///   ASYNC events are considered to match if their category, name and id values
+///   all match. |id| must either be a pointer or an integer value up to 64
+///   bits. If it's a pointer, the bits will be xored with a hash of the process
+///   ID sothat the same pointer on two different processes will not collide.
+/// An asynchronous operation can consist of multiple phases. The first phase is
+/// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
+/// ASYNC_STEP_BEGIN macros. When the operation completes, call ASYNC_END.
+/// An async operation can span threads and processes, but all events in that
+/// operation must use the same |name| and |id|. Each event can have its own
+/// args.
+///
 #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
-  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, false)
-#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val)    \
-  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
-                              0, false)
+  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0)
+#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, 0)
 #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
                                  arg2_name, arg2_val)                     \
   cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val,    \
-                              arg2_name, arg2_val, false)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
-  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
-  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL,   \
-                              0, true)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
-                                      arg2_name, arg2_val)                     \
-  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val,         \
-                              arg2_name, arg2_val, true)
+                              arg2_name, arg2_val)
 
-// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
-// category is not enabled, then this does nothing. The |name| and |id| must
-// match the ASYNC_BEGIN event above. The |step| param identifies this step
-// within the async event. This should be called at the beginning of the next
-// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
-// ASYNC_STEP_PAST events.
+///
+/// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
+/// category is not enabled, then this does nothing. The |name| and |id| must
+/// match the ASYNC_BEGIN event above. The |step| param identifies this step
+/// within the async event. This should be called at the beginning of the next
+/// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+/// ASYNC_STEP_PAST events.
+///
 #define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
-  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
+  cef_trace_event_async_step_into(category, name, id, step, NULL, 0)
 #define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
                                      arg1_val)                            \
-  cef_trace_event_async_step_into(category, name, id, step, arg1_name,    \
-                                  arg1_val, false)
-#define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
-  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
-                                          arg1_val)                            \
-  cef_trace_event_async_step_into(category, name, id, step, arg1_name,         \
-                                  arg1_val, true)
+  cef_trace_event_async_step_into(category, name, id, step, arg1_name, arg1_val)
 
-// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
-// category is not enabled, then this does nothing. The |name| and |id| must
-// match the ASYNC_BEGIN event above. The |step| param identifies this step
-// within the async event. This should be called at the beginning of the next
-// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
-// ASYNC_STEP_INTO events.
+///
+/// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
+/// category is not enabled, then this does nothing. The |name| and |id| must
+/// match the ASYNC_BEGIN event above. The |step| param identifies this step
+/// within the async event. This should be called at the beginning of the next
+/// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
+/// ASYNC_STEP_INTO events.
+///
 #define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
-  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
+  cef_trace_event_async_step_past(category, name, id, step, NULL, 0)
 #define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
                                      arg1_val)                            \
-  cef_trace_event_async_step_past(category, name, id, step, arg1_name,    \
-                                  arg1_val, false)
-#define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
-  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
-                                          arg1_val)                            \
-  cef_trace_event_async_step_past(category, name, id, step, arg1_name,         \
-                                  arg1_val, true)
+  cef_trace_event_async_step_past(category, name, id, step, arg1_name, arg1_val)
 
-// Records a single ASYNC_END event for "name" immediately. If the category
-// is not enabled, then this does nothing.
+///
+/// Records a single ASYNC_END event for "name" immediately. If the category
+/// is not enabled, then this does nothing.
+///
 #define TRACE_EVENT_ASYNC_END0(category, name, id) \
-  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, false)
-#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val)       \
-  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
-                            false)
+  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0)
+#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
+  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0)
 #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
                                arg2_name, arg2_val)                     \
   cef_trace_event_async_end(category, name, id, arg1_name, arg1_val,    \
-                            arg2_name, arg2_val, false)
-#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
-  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val)  \
-  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
-                            true)
-#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
-                                    arg2_name, arg2_val)                     \
-  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val,         \
-                            arg2_name, arg2_val, true)
+                            arg2_name, arg2_val)
 
 namespace cef_trace_event {
 
-// Used by TRACE_EVENTx macro. Do not use directly.
+///
+/// Used by TRACE_EVENTx macro. Do not use directly.
+///
 class CefTraceEndOnScopeClose {
  public:
   CefTraceEndOnScopeClose(const char* category, const char* name)
       : category_(category), name_(name) {}
   ~CefTraceEndOnScopeClose() {
-    cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
+    cef_trace_event_end(category_, name_, NULL, 0, NULL, 0);
   }
 
  private:
@@ -408,7 +377,7 @@ class CefTraceEndOnScopeClose {
   const char* name_;
 };
 
-}  // cef_trace_event
+}  // namespace cef_trace_event
 
 #endif  // !USING_CHROMIUM_INCLUDES
 

include/base/cef_tuple.h

@@ -28,25 +28,30 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Use std::tuple as tuple type. This file contains helper functions for
-// working with std::tuples.
-// The functions DispatchToMethod and DispatchToFunction take a function pointer
-// or instance and method pointer, and unpack a tuple into arguments to the
-// call.
-//
-// Example usage:
-//   // These two methods of creating a Tuple are identical.
-//   std::tuple<int, const char*> tuple_a(1, "wee");
-//   std::tuple<int, const char*> tuple_b = std::make_tuple(1, "wee");
-//
-//   void SomeFunc(int a, const char* b) { }
-//   DispatchToFunction(&SomeFunc, tuple_a);  // SomeFunc(1, "wee")
-//   DispatchToFunction(
-//       &SomeFunc, std::make_tuple(10, "foo"));    // SomeFunc(10, "foo")
-//
-//   struct { void SomeMeth(int a, int b, int c) { } } foo;
-//   DispatchToMethod(&foo, &Foo::SomeMeth, std::make_tuple(1, 2, 3));
-//   // foo->SomeMeth(1, 2, 3);
+///
+/// \file
+/// Use std::tuple as tuple type. This file contains helper functions for
+/// working with std::tuples.
+/// The functions DispatchToMethod and DispatchToFunction take a function
+/// pointer or instance and method pointer, and unpack a tuple into arguments to
+/// the call.
+///
+/// Example usage:
+/// <pre>
+///   // These two methods of creating a Tuple are identical.
+///   std::tuple<int, const char*> tuple_a(1, "wee");
+///   std::tuple<int, const char*> tuple_b = std::make_tuple(1, "wee");
+///
+///   void SomeFunc(int a, const char* b) { }
+///   DispatchToFunction(&SomeFunc, tuple_a);  // SomeFunc(1, "wee")
+///   DispatchToFunction(
+///       &SomeFunc, std::make_tuple(10, "foo"));    // SomeFunc(10, "foo")
+///
+///   struct { void SomeMeth(int a, int b, int c) { } } foo;
+///   DispatchToMethod(&foo, &Foo::SomeMeth, std::make_tuple(1, 2, 3));
+///   // foo->SomeMeth(1, 2, 3);
+/// </pre>
+///
 
 #ifndef CEF_INCLUDE_BASE_CEF_TUPLE_H_
 #define CEF_INCLUDE_BASE_CEF_TUPLE_H_
@@ -61,6 +66,7 @@
 // updated to match.
 
 #include <stddef.h>
+
 #include <tuple>
 #include <utility>
 
@@ -88,9 +94,7 @@ inline void DispatchToMethodImpl(const ObjT& obj,
 }
 
 template <typename ObjT, typename Method, typename Tuple>
-inline void DispatchToMethod(const ObjT& obj,
-                             Method method,
-                             Tuple&& args) {
+inline void DispatchToMethod(const ObjT& obj, Method method, Tuple&& args) {
   constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value;
   DispatchToMethodImpl(obj, method, std::forward<Tuple>(args),
                        std::make_index_sequence<size>());

include/base/cef_weak_ptr.h

@@ -28,69 +28,73 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Weak pointers are pointers to an object that do not affect its lifetime,
-// and which may be invalidated (i.e. reset to nullptr) by the object, or its
-// owner, at any time, most commonly when the object is about to be deleted.
-
-// Weak pointers are useful when an object needs to be accessed safely by one
-// or more objects other than its owner, and those callers can cope with the
-// object vanishing and e.g. tasks posted to it being silently dropped.
-// Reference-counting such an object would complicate the ownership graph and
-// make it harder to reason about the object's lifetime.
-
-// EXAMPLE:
-//
-//  class Controller {
-//   public:
-//    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
-//    void WorkComplete(const Result& result) { ... }
-//   private:
-//    // Member variables should appear before the WeakPtrFactory, to ensure
-//    // that any WeakPtrs to Controller are invalidated before its members
-//    // variable's destructors are executed, rendering them invalid.
-//    WeakPtrFactory<Controller> weak_factory_{this};
-//  };
-//
-//  class Worker {
-//   public:
-//    static void StartNew(WeakPtr<Controller> controller) {
-//      Worker* worker = new Worker(std::move(controller));
-//      // Kick off asynchronous processing...
-//    }
-//   private:
-//    Worker(WeakPtr<Controller> controller)
-//        : controller_(std::move(controller)) {}
-//    void DidCompleteAsynchronousProcessing(const Result& result) {
-//      if (controller_)
-//        controller_->WorkComplete(result);
-//    }
-//    WeakPtr<Controller> controller_;
-//  };
-//
-// With this implementation a caller may use SpawnWorker() to dispatch multiple
-// Workers and subsequently delete the Controller, without waiting for all
-// Workers to have completed.
-
-// ------------------------- IMPORTANT: Thread-safety -------------------------
-
-// Weak pointers may be passed safely between threads, but must always be
-// dereferenced and invalidated on the same ThreaddTaskRunner otherwise
-// checking the pointer would be racey.
-//
-// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
-// is dereferenced, the factory and its WeakPtrs become bound to the calling
-// thread or current ThreaddWorkerPool token, and cannot be dereferenced or
-// invalidated on any other task runner. Bound WeakPtrs can still be handed
-// off to other task runners, e.g. to use to post tasks back to object on the
-// bound thread.
-//
-// If all WeakPtr objects are destroyed or invalidated then the factory is
-// unbound from the ThreaddTaskRunner/Thread. The WeakPtrFactory may then be
-// destroyed, or new WeakPtr objects may be used, from a different thread.
-//
-// Thus, at least one WeakPtr object must exist and have been dereferenced on
-// the correct thread to enforce that other WeakPtr objects will enforce they
-// are used on the desired thread.
+///
+/// \file
+/// Weak pointers are pointers to an object that do not affect its lifetime.
+/// They may be invalidated (i.e. reset to nullptr) by the object, or its
+/// owner, at any time, most commonly when the object is about to be deleted.
+///
+/// Weak pointers are useful when an object needs to be accessed safely by one
+/// or more objects other than its owner, and those callers can cope with the
+/// object vanishing and e.g. tasks posted to it being silently dropped.
+/// Reference-counting such an object would complicate the ownership graph and
+/// make it harder to reason about the object's lifetime.
+///
+/// EXAMPLE:
+///
+/// <pre>
+///  class Controller {
+///   public:
+///    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
+///    void WorkComplete(const Result& result) { ... }
+///   private:
+///    // Member variables should appear before the WeakPtrFactory, to ensure
+///    // that any WeakPtrs to Controller are invalidated before its members
+///    // variable's destructors are executed, rendering them invalid.
+///    WeakPtrFactory<Controller> weak_factory_{this};
+///  };
+///
+///  class Worker {
+///   public:
+///    static void StartNew(WeakPtr<Controller> controller) {
+///      Worker* worker = new Worker(std::move(controller));
+///      // Kick off asynchronous processing...
+///    }
+///   private:
+///    Worker(WeakPtr<Controller> controller)
+///        : controller_(std::move(controller)) {}
+///    void DidCompleteAsynchronousProcessing(const Result& result) {
+///      if (controller_)
+///        controller_->WorkComplete(result);
+///    }
+///    WeakPtr<Controller> controller_;
+///  };
+/// </pre>
+///
+/// With this implementation a caller may use SpawnWorker() to dispatch multiple
+/// Workers and subsequently delete the Controller, without waiting for all
+/// Workers to have completed.
+///
+/// <b>IMPORTANT: Thread-safety</b>
+///
+/// Weak pointers may be passed safely between threads, but must always be
+/// dereferenced and invalidated on the same ThreaddTaskRunner otherwise
+/// checking the pointer would be racey.
+///
+/// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
+/// is dereferenced, the factory and its WeakPtrs become bound to the calling
+/// thread or current ThreaddWorkerPool token, and cannot be dereferenced or
+/// invalidated on any other task runner. Bound WeakPtrs can still be handed
+/// off to other task runners, e.g. to use to post tasks back to object on the
+/// bound thread.
+///
+/// If all WeakPtr objects are destroyed or invalidated then the factory is
+/// unbound from the ThreadedTaskRunner/Thread. The WeakPtrFactory may then be
+/// destroyed, or new WeakPtr objects may be used, from a different thread.
+///
+/// Thus, at least one WeakPtr object must exist and have been dereferenced on
+/// the correct thread to enforce that other WeakPtr objects will enforce they
+/// are used on the desired thread.
 
 #ifndef CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
 #define CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
@@ -119,7 +123,7 @@ class SupportsWeakPtr;
 template <typename T>
 class WeakPtr;
 
-namespace internal {
+namespace cef_internal {
 // These classes are part of the WeakPtr implementation.
 // DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
 
@@ -193,7 +197,7 @@ class WeakPtrBase {
   WeakPtrBase& operator=(WeakPtrBase&& other) noexcept = default;
 
   void reset() {
-    ref_ = internal::WeakReference();
+    ref_ = cef_internal::WeakReference();
     ptr_ = 0;
   }
 
@@ -221,7 +225,7 @@ class SupportsWeakPtrBase {
   template <typename Derived>
   static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
     static_assert(
-        std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
+        std::is_base_of<cef_internal::SupportsWeakPtrBase, Derived>::value,
         "AsWeakPtr argument must inherit from SupportsWeakPtr");
     return AsWeakPtrImpl<Derived>(t);
   }
@@ -238,32 +242,37 @@ class SupportsWeakPtrBase {
   }
 };
 
-}  // namespace internal
+}  // namespace cef_internal
 
 template <typename T>
 class WeakPtrFactory;
 
-// The WeakPtr class holds a weak reference to |T*|.
-//
-// This class is designed to be used like a normal pointer.  You should always
-// null-test an object of this class before using it or invoking a method that
-// may result in the underlying object being destroyed.
-//
-// EXAMPLE:
-//
-//   class Foo { ... };
-//   WeakPtr<Foo> foo;
-//   if (foo)
-//     foo->method();
-//
+///
+/// The WeakPtr class holds a weak reference to |T*|.
+///
+/// This class is designed to be used like a normal pointer.  You should always
+/// null-test an object of this class before using it or invoking a method that
+/// may result in the underlying object being destroyed.
+///
+/// EXAMPLE:
+///
+/// <pre>
+///   class Foo { ... };
+///   WeakPtr<Foo> foo;
+///   if (foo)
+///     foo->method();
+/// </pre>
+///
 template <typename T>
-class WeakPtr : public internal::WeakPtrBase {
+class WeakPtr : public cef_internal::WeakPtrBase {
  public:
   WeakPtr() = default;
   WeakPtr(std::nullptr_t) {}
 
-  // Allow conversion from U to T provided U "is a" T. Note that this
-  // is separate from the (implicit) copy and move constructors.
+  ///
+  /// Allow conversion from U to T provided U "is a" T. Note that this
+  /// is separate from the (implicit) copy and move constructors.
+  ///
   template <typename U>
   WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other) {
     // Need to cast from U* to T* to do pointer adjustment in case of multiple
@@ -292,35 +301,43 @@ class WeakPtr : public internal::WeakPtrBase {
     return get();
   }
 
-  // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
+  ///
+  /// Allow conditionals to test validity, e.g. `if (weak_ptr) {...}`;
+  ///
   explicit operator bool() const { return get() != nullptr; }
 
-  // Returns false if the WeakPtr is confirmed to be invalid. This call is safe
-  // to make from any thread, e.g. to optimize away unnecessary work, but
-  // operator bool() must always be called, on the correct thread, before
-  // actually using the pointer.
-  //
-  // Warning: as with any object, this call is only thread-safe if the WeakPtr
-  // instance isn't being re-assigned or reset() racily with this call.
+  ///
+  /// Returns false if the WeakPtr is confirmed to be invalid. This call is safe
+  /// to make from any thread, e.g. to optimize away unnecessary work, but
+  /// operator bool() must always be called, on the correct thread, before
+  /// actually using the pointer.
+  ///
+  /// Warning: as with any object, this call is only thread-safe if the WeakPtr
+  /// instance isn't being re-assigned or reset() racily with this call.
+  ///
   bool MaybeValid() const { return ref_.MaybeValid(); }
 
-  // Returns whether the object |this| points to has been invalidated. This can
-  // be used to distinguish a WeakPtr to a destroyed object from one that has
-  // been explicitly set to null.
+  ///
+  /// Returns whether the object |this| points to has been invalidated. This can
+  /// be used to distinguish a WeakPtr to a destroyed object from one that has
+  /// been explicitly set to null.
+  ///
   bool WasInvalidated() const { return ptr_ && !ref_.IsValid(); }
 
  private:
-  friend class internal::SupportsWeakPtrBase;
+  friend class cef_internal::SupportsWeakPtrBase;
   template <typename U>
   friend class WeakPtr;
   friend class SupportsWeakPtr<T>;
   friend class WeakPtrFactory<T>;
 
-  WeakPtr(const internal::WeakReference& ref, T* ptr)
+  WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
       : WeakPtrBase(ref, reinterpret_cast<uintptr_t>(ptr)) {}
 };
 
-// Allow callers to compare WeakPtrs against nullptr to test validity.
+///
+/// Allow callers to compare WeakPtrs against nullptr to test validity.
+///
 template <class T>
 bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
   return !(weak_ptr == nullptr);
@@ -338,23 +355,26 @@ bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
   return weak_ptr == nullptr;
 }
 
-namespace internal {
+namespace cef_internal {
 class WeakPtrFactoryBase {
  protected:
   WeakPtrFactoryBase(uintptr_t ptr);
   ~WeakPtrFactoryBase();
-  internal::WeakReferenceOwner weak_reference_owner_;
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
   uintptr_t ptr_;
 };
-}  // namespace internal
+}  // namespace cef_internal
 
-// A class may be composed of a WeakPtrFactory and thereby
-// control how it exposes weak pointers to itself.  This is helpful if you only
-// need weak pointers within the implementation of a class.  This class is also
-// useful when working with primitive types.  For example, you could have a
-// WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
+///
+/// A class may be composed of a WeakPtrFactory and thereby control how it
+/// exposes weak pointers to itself.  This is helpful if you only need weak
+/// pointers within the implementation of a class.  This class is also useful
+/// when working with primitive types.  For example, you could have a
+/// WeakPtrFactory<bool> that is used to pass around a weak reference to a
+/// bool.
+///
 template <class T>
-class WeakPtrFactory : public internal::WeakPtrFactoryBase {
+class WeakPtrFactory : public cef_internal::WeakPtrFactoryBase {
  public:
   WeakPtrFactory() = delete;
 
@@ -371,26 +391,32 @@ class WeakPtrFactory : public internal::WeakPtrFactoryBase {
                       reinterpret_cast<T*>(ptr_));
   }
 
-  // Call this method to invalidate all existing weak pointers.
+  ///
+  /// Call this method to invalidate all existing weak pointers.
+  ///
   void InvalidateWeakPtrs() {
     DCHECK(ptr_);
     weak_reference_owner_.Invalidate();
   }
 
-  // Call this method to determine if any weak pointers exist.
+  ///
+  /// Call this method to determine if any weak pointers exist.
+  ///
   bool HasWeakPtrs() const {
     DCHECK(ptr_);
     return weak_reference_owner_.HasRefs();
   }
 };
 
-// A class may extend from SupportsWeakPtr to let others take weak pointers to
-// it. This avoids the class itself implementing boilerplate to dispense weak
-// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
-// weak pointers to the class until after the derived class' members have been
-// destroyed, its use can lead to subtle use-after-destroy issues.
+///
+/// A class may extend from SupportsWeakPtr to let others take weak pointers to
+/// it. This avoids the class itself implementing boilerplate to dispense weak
+/// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
+/// weak pointers to the class until after the derived class' members have been
+/// destroyed, its use can lead to subtle use-after-destroy issues.
+///
 template <class T>
-class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
+class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
  public:
   SupportsWeakPtr() = default;
 
@@ -405,30 +431,35 @@ class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
   ~SupportsWeakPtr() = default;
 
  private:
-  internal::WeakReferenceOwner weak_reference_owner_;
+  cef_internal::WeakReferenceOwner weak_reference_owner_;
 };
 
-// Helper function that uses type deduction to safely return a WeakPtr<Derived>
-// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
-// extends a Base that extends SupportsWeakPtr<Base>.
-//
-// EXAMPLE:
-//   class Base : public base::SupportsWeakPtr<Producer> {};
-//   class Derived : public Base {};
-//
-//   Derived derived;
-//   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
-//
-// Note that the following doesn't work (invalid type conversion) since
-// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
-// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
-// the caller.
-//
-//   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
-
+///
+/// Helper function that uses type deduction to safely return a WeakPtr<Derived>
+/// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
+/// extends a Base that extends SupportsWeakPtr<Base>.
+///
+/// EXAMPLE:
+/// <pre>
+///   class Base : public base::SupportsWeakPtr<Producer> {};
+///   class Derived : public Base {};
+///
+///   Derived derived;
+///   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
+/// </pre>
+///
+/// Note that the following doesn't work (invalid type conversion) since
+/// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
+/// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
+/// the caller.
+///
+/// <pre>
+///   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
+/// </pre>
+///
 template <typename Derived>
 WeakPtr<Derived> AsWeakPtr(Derived* t) {
-  return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
+  return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
 }
 
 }  // namespace base

include/base/internal/cef_bind_internal.h

@@ -68,7 +68,6 @@
 #include "include/base/cef_build.h"
 #include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
-#include "include/base/cef_template_util.h"
 #include "include/base/cef_weak_ptr.h"
 #include "include/base/internal/cef_callback_internal.h"
 #include "include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h"
@@ -97,7 +96,7 @@ struct BindUnwrapTraits;
 template <typename Functor, typename BoundArgsTuple, typename SFINAE = void>
 struct CallbackCancellationTraits;
 
-namespace internal {
+namespace cef_internal {
 
 template <typename Functor, typename SFINAE = void>
 struct FunctorTraits;
@@ -356,14 +355,14 @@ template <typename Functor, typename SFINAE = void>
 struct IsCallableObject : std::false_type {};
 
 template <typename Callable>
-struct IsCallableObject<Callable, void_t<decltype(&Callable::operator())>>
+struct IsCallableObject<Callable, std::void_t<decltype(&Callable::operator())>>
     : std::true_type {};
 
 // HasRefCountedTypeAsRawPtr inherits from true_type when any of the |Args| is a
 // raw pointer to a RefCounted type.
 template <typename... Ts>
 struct HasRefCountedTypeAsRawPtr
-    : disjunction<NeedsScopedRefptrButGetsRawPtr<Ts>...> {};
+    : std::disjunction<NeedsScopedRefptrButGetsRawPtr<Ts>...> {};
 
 // ForceVoidReturn<>
 //
@@ -687,8 +686,9 @@ struct InvokeHelper<true, ReturnType> {
   static inline void MakeItSo(Functor&& functor,
                               BoundWeakPtr&& weak_ptr,
                               RunArgs&&... args) {
-    if (!weak_ptr)
+    if (!weak_ptr) {
       return;
+    }
     using Traits = MakeFunctorTraits<Functor>;
     Traits::Invoke(std::forward<Functor>(functor),
                    std::forward<BoundWeakPtr>(weak_ptr),
@@ -877,7 +877,7 @@ BanUnconstructedRefCountedReceiver(const Receiver& receiver, Unused&&...) {
 // This stores all the state passed into Bind().
 template <typename Functor, typename... BoundArgs>
 struct BindState final : BindStateBase {
-  using IsCancellable = bool_constant<
+  using IsCancellable = std::bool_constant<
       CallbackCancellationTraits<Functor,
                                  std::tuple<BoundArgs...>>::is_cancellable>;
   template <typename ForwardFunctor, typename... ForwardBoundArgs>
@@ -1189,7 +1189,11 @@ struct AssertBindArgsValidity<std::index_sequence<Ns...>,
                               TypeList<Args...>,
                               TypeList<Unwrapped...>,
                               TypeList<Params...>>
-    : AssertConstructible<Ns, Args, std::decay_t<Args>, Unwrapped, Params>... {
+    : AssertConstructible<static_cast<int>(Ns),
+                          Args,
+                          std::decay_t<Args>,
+                          Unwrapped,
+                          Params>... {
   static constexpr bool ok = true;
 };
 
@@ -1247,7 +1251,7 @@ decltype(auto) BindImpl(Functor&& functor, Args&&... args) {
   // PolymorphicInvoke, to which CallbackType will cast back.
   using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
   PolymorphicInvoke invoke_func =
-      GetInvokeFunc<Invoker>(bool_constant<kIsOnce>());
+      GetInvokeFunc<Invoker>(std::bool_constant<kIsOnce>());
 
   using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
   return CallbackType(BindState::Create(
@@ -1255,7 +1259,7 @@ decltype(auto) BindImpl(Functor&& functor, Args&&... args) {
       std::forward<Functor>(functor), std::forward<Args>(args)...));
 }
 
-}  // namespace internal
+}  // namespace cef_internal
 
 // An injection point to control |this| pointer behavior on a method invocation.
 // If IsWeakReceiver<> is true_type for |T| and |T| is used for a receiver of a
@@ -1299,30 +1303,36 @@ struct BindUnwrapTraits {
 };
 
 template <typename T>
-struct BindUnwrapTraits<internal::UnretainedWrapper<T>> {
-  static T* Unwrap(const internal::UnretainedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::RetainedRefWrapper<T>> {
-  static T* Unwrap(const internal::RetainedRefWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T, typename Deleter>
-struct BindUnwrapTraits<internal::OwnedWrapper<T, Deleter>> {
-  static T* Unwrap(const internal::OwnedWrapper<T, Deleter>& o) {
+struct BindUnwrapTraits<cef_internal::UnretainedWrapper<T>> {
+  static T* Unwrap(const cef_internal::UnretainedWrapper<T>& o) {
     return o.get();
   }
 };
 
 template <typename T>
-struct BindUnwrapTraits<internal::OwnedRefWrapper<T>> {
-  static T& Unwrap(const internal::OwnedRefWrapper<T>& o) { return o.get(); }
+struct BindUnwrapTraits<cef_internal::RetainedRefWrapper<T>> {
+  static T* Unwrap(const cef_internal::RetainedRefWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T, typename Deleter>
+struct BindUnwrapTraits<cef_internal::OwnedWrapper<T, Deleter>> {
+  static T* Unwrap(const cef_internal::OwnedWrapper<T, Deleter>& o) {
+    return o.get();
+  }
 };
 
 template <typename T>
-struct BindUnwrapTraits<internal::PassedWrapper<T>> {
-  static T Unwrap(const internal::PassedWrapper<T>& o) { return o.Take(); }
+struct BindUnwrapTraits<cef_internal::OwnedRefWrapper<T>> {
+  static T& Unwrap(const cef_internal::OwnedRefWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<cef_internal::PassedWrapper<T>> {
+  static T Unwrap(const cef_internal::PassedWrapper<T>& o) { return o.Take(); }
 };
 
 #if defined(OS_WIN)
@@ -1346,9 +1356,9 @@ template <typename Functor, typename... BoundArgs>
 struct CallbackCancellationTraits<
     Functor,
     std::tuple<BoundArgs...>,
-    std::enable_if_t<
-        internal::IsWeakMethod<internal::FunctorTraits<Functor>::is_method,
-                               BoundArgs...>::value>> {
+    std::enable_if_t<cef_internal::IsWeakMethod<
+        cef_internal::FunctorTraits<Functor>::is_method,
+        BoundArgs...>::value>> {
   static constexpr bool is_cancellable = true;
 
   template <typename Receiver, typename... Args>

include/base/internal/cef_callback_internal.h

@@ -43,7 +43,7 @@ namespace base {
 
 struct FakeBindState;
 
-namespace internal {
+namespace cef_internal {
 
 class BindStateBase;
 class FinallyExecutorCommon;
@@ -269,7 +269,7 @@ struct ThenHelper<OriginalCallback<OriginalR(OriginalArgs...)>,
   }
 };
 
-}  // namespace internal
+}  // namespace cef_internal
 }  // namespace base
 
 #endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_

include/base/internal/cef_color_id_macros.inc

@@ -0,0 +1,50 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// The following macros are used to declare both the color id enumerations and
+// the stringized names of the enumeration elements for use in dump_colors. To
+// stringize the element names, define STRINGIZE_COLOR_IDS prior to including
+// this file. This file is intended to be included just before and just after
+// the enumeration or string array declarations.
+
+#if !defined(COLOR_ID_MACROS_DEFINED)
+#define COLOR_ID_MACROS_DEFINED
+#if defined(STRINGIZE_COLOR_IDS)
+// Convert first token to string, throw away the rest.
+#define D1(enum_name) #enum_name
+#define D2(enum_name, enum_value) #enum_name
+#else  // defined(STRINGIZE_COLOR_IDS)
+// Declare enum with optional assigned value.
+#define D1(enum_name) enum_name
+#define D2(enum_name, enum_value) enum_name = enum_value
+#endif  // defined(STRINGIZE_COLOR_IDS)
+// Select which token in the declaration is the assigned value.
+// Use first and optional third token, ignore optional second.
+#define E1(enum_name) D1(enum_name)
+#define E2(enum_name, old_enum_name) D1(enum_name)
+#define E3(enum_name, old_enum_name, enum_value) D2(enum_name, enum_value)
+#define GET_E(_1, _2, _3, macro_name, ...) macro_name
+#if defined(COMPILER_MSVC)
+// Workaround for MSVC not properly expanding __VA_ARGS__.
+#define EXPAND(x) x
+#define E_CPONLY(...) EXPAND(E(__VA_ARGS__))
+#define E(...) EXPAND(GET_E(__VA_ARGS__, E3, E2, E1)(__VA_ARGS__)),
+#else  // !defined(COMPILER_MSVC)
+#define E_CPONLY(...) E(__VA_ARGS__)
+#define E(...) GET_E(__VA_ARGS__, E3, E2, E1)(__VA_ARGS__),
+#endif // !defined(COMPILER_MSVC)
+#else  // !defined(COLOR_ID_MACROS_DEFINED)
+#undef D1
+#undef D2
+#undef E1
+#undef E2
+#undef E3
+#if defined(COMPILER_MSVC)
+#undef EXPAND
+#endif
+#undef E_CPONLY
+#undef GET_E
+#undef E
+#undef COLOR_ID_MACROS_DEFINED
+#endif  // !defined(COLOR_ID_MACROS_DEFINED)

include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h

@@ -34,8 +34,6 @@
 
 #include <type_traits>
 
-#include "include/base/cef_template_util.h"
-
 // It is dangerous to post a task with a T* argument where T is a subtype of
 // RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
 // object may already have been deleted since it was not held with a
@@ -47,28 +45,28 @@ namespace base {
 
 // This is a base internal implementation file used by task.h and callback.h.
 // Not for public consumption, so we wrap it in namespace internal.
-namespace internal {
+namespace cef_internal {
 
 template <typename T, typename = void>
 struct IsRefCountedType : std::false_type {};
 
 template <typename T>
 struct IsRefCountedType<T,
-                        void_t<decltype(std::declval<T*>()->AddRef()),
-                               decltype(std::declval<T*>()->Release())>>
+                        std::void_t<decltype(std::declval<T*>()->AddRef()),
+                                    decltype(std::declval<T*>()->Release())>>
     : std::true_type {};
 
 // Human readable translation: you needed to be a scoped_refptr if you are a raw
 // pointer type and are convertible to a RefCounted(Base|ThreadSafeBase) type.
 template <typename T>
 struct NeedsScopedRefptrButGetsRawPtr
-    : conjunction<std::is_pointer<T>,
-                  IsRefCountedType<std::remove_pointer_t<T>>> {
+    : std::conjunction<std::is_pointer<T>,
+                       IsRefCountedType<std::remove_pointer_t<T>>> {
   static_assert(!std::is_reference<T>::value,
                 "NeedsScopedRefptrButGetsRawPtr requires non-reference type.");
 };
 
-}  // namespace internal
+}  // namespace cef_internal
 
 }  // namespace base
 

include/base/internal/cef_scoped_block_mac.h

@@ -38,13 +38,14 @@
 #include "include/base/cef_scoped_typeref_mac.h"
 
 #if defined(__has_feature) && __has_feature(objc_arc)
-#error "Cannot include include/base/internal/cef_scoped_block_mac.h in file built with ARC."
+#error \
+    "Cannot include include/base/internal/cef_scoped_block_mac.h in file built with ARC."
 #endif
 
 namespace base {
 namespace mac {
 
-namespace internal {
+namespace cef_internal {
 
 template <typename B>
 struct ScopedBlockTraits {
@@ -53,12 +54,12 @@ struct ScopedBlockTraits {
   static void Release(B block) { Block_release(block); }
 };
 
-}  // namespace internal
+}  // namespace cef_internal
 
 // ScopedBlock<> is patterned after ScopedCFTypeRef<>, but uses Block_copy() and
 // Block_release() instead of CFRetain() and CFRelease().
 template <typename B>
-using ScopedBlock = ScopedTypeRef<B, internal::ScopedBlockTraits<B>>;
+using ScopedBlock = ScopedTypeRef<B, cef_internal::ScopedBlockTraits<B>>;
 
 }  // namespace mac
 }  // namespace base

include/capi/cef_accessibility_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=306e44d49ab6198a0fa1bcea50e8a25ee18672be$
+// $hash=6ea5d772fb4961ae4a658b4b730aa608fa93309f$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
@@ -47,27 +47,27 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to receive accessibility notification when
-// accessibility events have been registered. The functions of this structure
-// will be called on the UI thread.
+/// Implement this structure to receive accessibility notification when
+/// accessibility events have been registered. The functions of this structure
+/// will be called on the UI thread.
 ///
 typedef struct _cef_accessibility_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called after renderer process sends accessibility tree changes to the
-  // browser process.
+  /// Called after renderer process sends accessibility tree changes to the
+  /// browser process.
   ///
   void(CEF_CALLBACK* on_accessibility_tree_change)(
       struct _cef_accessibility_handler_t* self,
       struct _cef_value_t* value);
 
   ///
-  // Called after renderer process sends accessibility location changes to the
-  // browser process.
+  /// Called after renderer process sends accessibility location changes to the
+  /// browser process.
   ///
   void(CEF_CALLBACK* on_accessibility_location_change)(
       struct _cef_accessibility_handler_t* self,

include/capi/cef_app_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=665709ecf3ebad59e85285d319eae72197b9766f$
+// $hash=608f4520d7901b6e18bf9164c9460f1b75bad8f4$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@@ -54,25 +54,26 @@ extern "C" {
 struct _cef_app_t;
 
 ///
-// Implement this structure to provide handler implementations. Methods will be
-// called by the process and/or thread indicated.
+/// Implement this structure to provide handler implementations. Methods will be
+/// called by the process and/or thread indicated.
 ///
 typedef struct _cef_app_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Provides an opportunity to view and/or modify command-line arguments before
-  // processing by CEF and Chromium. The |process_type| value will be NULL for
-  // the browser process. Do not keep a reference to the cef_command_line_t
-  // object passed to this function. The CefSettings.command_line_args_disabled
-  // value can be used to start with an NULL command-line object. Any values
-  // specified in CefSettings that equate to command-line arguments will be set
-  // before this function is called. Be cautious when using this function to
-  // modify command-line arguments for non-browser processes as this may result
-  // in undefined behavior including crashes.
+  /// Provides an opportunity to view and/or modify command-line arguments
+  /// before processing by CEF and Chromium. The |process_type| value will be
+  /// NULL for the browser process. Do not keep a reference to the
+  /// cef_command_line_t object passed to this function. The
+  /// cef_settings_t.command_line_args_disabled value can be used to start with
+  /// an NULL command-line object. Any values specified in CefSettings that
+  /// equate to command-line arguments will be set before this function is
+  /// called. Be cautious when using this function to modify command-line
+  /// arguments for non-browser processes as this may result in undefined
+  /// behavior including crashes.
   ///
   void(CEF_CALLBACK* on_before_command_line_processing)(
       struct _cef_app_t* self,
@@ -80,120 +81,121 @@ typedef struct _cef_app_t {
       struct _cef_command_line_t* command_line);
 
   ///
-  // Provides an opportunity to register custom schemes. Do not keep a reference
-  // to the |registrar| object. This function is called on the main thread for
-  // each process and the registered schemes should be the same across all
-  // processes.
+  /// Provides an opportunity to register custom schemes. Do not keep a
+  /// reference to the |registrar| object. This function is called on the main
+  /// thread for each process and the registered schemes should be the same
+  /// across all processes.
   ///
   void(CEF_CALLBACK* on_register_custom_schemes)(
       struct _cef_app_t* self,
       struct _cef_scheme_registrar_t* registrar);
 
   ///
-  // Return the handler for resource bundle events. If
-  // CefSettings.pack_loading_disabled is true (1) a handler must be returned.
-  // If no handler is returned resources will be loaded from pack files. This
-  // function is called by the browser and render processes on multiple threads.
+  /// Return the handler for resource bundle events. If no handler is returned
+  /// resources will be loaded from pack files. This function is called by the
+  /// browser and render processes on multiple threads.
   ///
   struct _cef_resource_bundle_handler_t*(
       CEF_CALLBACK* get_resource_bundle_handler)(struct _cef_app_t* self);
 
   ///
-  // Return the handler for functionality specific to the browser process. This
-  // function is called on multiple threads in the browser process.
+  /// Return the handler for functionality specific to the browser process. This
+  /// function is called on multiple threads in the browser process.
   ///
   struct _cef_browser_process_handler_t*(
       CEF_CALLBACK* get_browser_process_handler)(struct _cef_app_t* self);
 
   ///
-  // Return the handler for functionality specific to the render process. This
-  // function is called on the render process main thread.
+  /// Return the handler for functionality specific to the render process. This
+  /// function is called on the render process main thread.
   ///
   struct _cef_render_process_handler_t*(
       CEF_CALLBACK* get_render_process_handler)(struct _cef_app_t* self);
 } cef_app_t;
 
 ///
-// This function should be called from the application entry point function to
-// execute a secondary process. It can be used to run secondary processes from
-// the browser client executable (default behavior) or from a separate
-// executable specified by the CefSettings.browser_subprocess_path value. If
-// called for the browser process (identified by no "type" command-line value)
-// it will return immediately with a value of -1. If called for a recognized
-// secondary process it will block until the process should exit and then return
-// the process exit code. The |application| parameter may be NULL. The
-// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
-// cef_sandbox_win.h for details).
+/// This function should be called from the application entry point function to
+/// execute a secondary process. It can be used to run secondary processes from
+/// the browser client executable (default behavior) or from a separate
+/// executable specified by the cef_settings_t.browser_subprocess_path value. If
+/// called for the browser process (identified by no "type" command-line value)
+/// it will return immediately with a value of -1. If called for a recognized
+/// secondary process it will block until the process should exit and then
+/// return the process exit code. The |application| parameter may be NULL. The
+/// |windows_sandbox_info| parameter is only used on Windows and may be NULL
+/// (see cef_sandbox_win.h for details).
 ///
-CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
+CEF_EXPORT int cef_execute_process(const cef_main_args_t* args,
                                    cef_app_t* application,
                                    void* windows_sandbox_info);
 
 ///
-// This function should be called on the main application thread to initialize
-// the CEF browser process. The |application| parameter may be NULL. A return
-// value of true (1) indicates that it succeeded and false (0) indicates that it
-// failed. The |windows_sandbox_info| parameter is only used on Windows and may
-// be NULL (see cef_sandbox_win.h for details).
+/// This function should be called on the main application thread to initialize
+/// the CEF browser process. The |application| parameter may be NULL. Returns
+/// true (1) if initialization succeeds. Returns false (0) if initialization
+/// fails or if early exit is desired (for example, due to process singleton
+/// relaunch behavior). If this function returns false (0) then the application
+/// should exit immediately without calling any other CEF functions except,
+/// optionally, CefGetErrorCode. The |windows_sandbox_info| parameter is only
+/// used on Windows and may be NULL (see cef_sandbox_win.h for details).
 ///
-CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
+CEF_EXPORT int cef_initialize(const cef_main_args_t* args,
                               const struct _cef_settings_t* settings,
                               cef_app_t* application,
                               void* windows_sandbox_info);
 
 ///
-// This function should be called on the main application thread to shut down
-// the CEF browser process before the application exits.
+/// This function can optionally be called on the main application thread after
+/// CefInitialize to retrieve the initialization exit code. When CefInitialize
+/// returns true (1) the exit code will be 0 (CEF_RESULT_CODE_NORMAL_EXIT).
+/// Otherwise, see cef_resultcode_t for possible exit code values including
+/// browser process initialization errors and normal early exit conditions (such
+/// as CEF_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED for process singleton
+/// relaunch behavior).
+///
+CEF_EXPORT int cef_get_exit_code(void);
+
+///
+/// This function should be called on the main application thread to shut down
+/// the CEF browser process before the application exits. Do not call any other
+/// CEF functions after calling this function.
 ///
 CEF_EXPORT void cef_shutdown(void);
 
 ///
-// Perform a single iteration of CEF message loop processing. This function is
-// provided for cases where the CEF message loop must be integrated into an
-// existing application message loop. Use of this function is not recommended
-// for most users; use either the cef_run_message_loop() function or
-// CefSettings.multi_threaded_message_loop if possible. When using this function
-// care must be taken to balance performance against excessive CPU usage. It is
-// recommended to enable the CefSettings.external_message_pump option when using
-// this function so that
-// cef_browser_process_handler_t::on_schedule_message_pump_work() callbacks can
-// facilitate the scheduling process. This function should only be called on the
-// main application thread and only if cef_initialize() is called with a
-// CefSettings.multi_threaded_message_loop value of false (0). This function
-// will not block.
+/// Perform a single iteration of CEF message loop processing. This function is
+/// provided for cases where the CEF message loop must be integrated into an
+/// existing application message loop. Use of this function is not recommended
+/// for most users; use either the cef_run_message_loop() function or
+/// cef_settings_t.multi_threaded_message_loop if possible. When using this
+/// function care must be taken to balance performance against excessive CPU
+/// usage. It is recommended to enable the cef_settings_t.external_message_pump
+/// option when using this function so that
+/// cef_browser_process_handler_t::on_schedule_message_pump_work() callbacks can
+/// facilitate the scheduling process. This function should only be called on
+/// the main application thread and only if cef_initialize() is called with a
+/// cef_settings_t.multi_threaded_message_loop value of false (0). This function
+/// will not block.
 ///
 CEF_EXPORT void cef_do_message_loop_work(void);
 
 ///
-// Run the CEF message loop. Use this function instead of an application-
-// provided message loop to get the best balance between performance and CPU
-// usage. This function should only be called on the main application thread and
-// only if cef_initialize() is called with a
-// CefSettings.multi_threaded_message_loop value of false (0). This function
-// will block until a quit message is received by the system.
+/// Run the CEF message loop. Use this function instead of an application-
+/// provided message loop to get the best balance between performance and CPU
+/// usage. This function should only be called on the main application thread
+/// and only if cef_initialize() is called with a
+/// cef_settings_t.multi_threaded_message_loop value of false (0). This function
+/// will block until a quit message is received by the system.
 ///
 CEF_EXPORT void cef_run_message_loop(void);
 
 ///
-// Quit the CEF message loop that was started by calling cef_run_message_loop().
-// This function should only be called on the main application thread and only
-// if cef_run_message_loop() was used.
+/// Quit the CEF message loop that was started by calling
+/// cef_run_message_loop(). This function should only be called on the main
+/// application thread and only if cef_run_message_loop() was used.
 ///
 CEF_EXPORT void cef_quit_message_loop(void);
 
-///
-// Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
-// modal message loop. Set to false (0) after exiting the modal message loop.
-///
-CEF_EXPORT void cef_set_osmodal_loop(int osModalLoop);
-
-///
-// Call during process startup to enable High-DPI support on Windows 7 or newer.
-// Older versions of Windows should be left DPI-unaware because they do not
-// support DirectWrite and GDI fonts are kerned very badly.
-///
-CEF_EXPORT void cef_enable_highdpi_support(void);
-
 #ifdef __cplusplus
 }
 #endif

include/capi/cef_audio_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=fd8d34089842ee8f8490ef1828c3091d12052e28$
+// $hash=d98482eba93dcd8b6a6f69b2732162733c73203d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_
@@ -48,30 +48,30 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle audio events.
+/// Implement this structure to handle audio events.
 ///
 typedef struct _cef_audio_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called on the UI thread to allow configuration of audio stream parameters.
-  // Return true (1) to proceed with audio stream capture, or false (0) to
-  // cancel it. All members of |params| can optionally be configured here, but
-  // they are also pre-filled with some sensible defaults.
+  /// Called on the UI thread to allow configuration of audio stream parameters.
+  /// Return true (1) to proceed with audio stream capture, or false (0) to
+  /// cancel it. All members of |params| can optionally be configured here, but
+  /// they are also pre-filled with some sensible defaults.
   ///
   int(CEF_CALLBACK* get_audio_parameters)(struct _cef_audio_handler_t* self,
                                           struct _cef_browser_t* browser,
                                           cef_audio_parameters_t* params);
 
   ///
-  // Called on a browser audio capture thread when the browser starts streaming
-  // audio. OnAudioSteamStopped will always be called after
-  // OnAudioStreamStarted; both functions may be called multiple times for the
-  // same browser. |params| contains the audio parameters like sample rate and
-  // channel layout. |channels| is the number of channels.
+  /// Called on a browser audio capture thread when the browser starts streaming
+  /// audio. OnAudioStreamStopped will always be called after
+  /// OnAudioStreamStarted; both functions may be called multiple times for the
+  /// same browser. |params| contains the audio parameters like sample rate and
+  /// channel layout. |channels| is the number of channels.
   ///
   void(CEF_CALLBACK* on_audio_stream_started)(
       struct _cef_audio_handler_t* self,
@@ -80,34 +80,34 @@ typedef struct _cef_audio_handler_t {
       int channels);
 
   ///
-  // Called on the audio stream thread when a PCM packet is received for the
-  // stream. |data| is an array representing the raw PCM data as a floating
-  // point type, i.e. 4-byte value(s). |frames| is the number of frames in the
-  // PCM packet. |pts| is the presentation timestamp (in milliseconds since the
-  // Unix Epoch) and represents the time at which the decompressed packet should
-  // be presented to the user. Based on |frames| and the |channel_layout| value
-  // passed to OnAudioStreamStarted you can calculate the size of the |data|
-  // array in bytes.
+  /// Called on the audio stream thread when a PCM packet is received for the
+  /// stream. |data| is an array representing the raw PCM data as a floating
+  /// point type, i.e. 4-byte value(s). |frames| is the number of frames in the
+  /// PCM packet. |pts| is the presentation timestamp (in milliseconds since the
+  /// Unix Epoch) and represents the time at which the decompressed packet
+  /// should be presented to the user. Based on |frames| and the
+  /// |channel_layout| value passed to OnAudioStreamStarted you can calculate
+  /// the size of the |data| array in bytes.
   ///
   void(CEF_CALLBACK* on_audio_stream_packet)(struct _cef_audio_handler_t* self,
                                              struct _cef_browser_t* browser,
                                              const float** data,
                                              int frames,
-                                             int64 pts);
+                                             int64_t pts);
 
   ///
-  // Called on the UI thread when the stream has stopped. OnAudioSteamStopped
-  // will always be called after OnAudioStreamStarted; both functions may be
-  // called multiple times for the same stream.
+  /// Called on the UI thread when the stream has stopped. OnAudioSteamStopped
+  /// will always be called after OnAudioStreamStarted; both functions may be
+  /// called multiple times for the same stream.
   ///
   void(CEF_CALLBACK* on_audio_stream_stopped)(struct _cef_audio_handler_t* self,
                                               struct _cef_browser_t* browser);
 
   ///
-  // Called on the UI or audio stream thread when an error occurred. During the
-  // stream creation phase this callback will be called on the UI thread while
-  // in the capturing phase it will be called on the audio stream thread. The
-  // stream will be stopped immediately.
+  /// Called on the UI or audio stream thread when an error occurred. During the
+  /// stream creation phase this callback will be called on the UI thread while
+  /// in the capturing phase it will be called on the audio stream thread. The
+  /// stream will be stopped immediately.
   ///
   void(CEF_CALLBACK* on_audio_stream_error)(struct _cef_audio_handler_t* self,
                                             struct _cef_browser_t* browser,

include/capi/cef_auth_callback_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=01a33de48ac9780f78d606d8aee2429ddb0c81a2$
+// $hash=b63947918eca8c31790cae16b2e8a0be7e9464dd$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
@@ -47,24 +47,24 @@ extern "C" {
 #endif
 
 ///
-// Callback structure used for asynchronous continuation of authentication
-// requests.
+/// Callback structure used for asynchronous continuation of authentication
+/// requests.
 ///
 typedef struct _cef_auth_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Continue the authentication request.
+  /// Continue the authentication request.
   ///
   void(CEF_CALLBACK* cont)(struct _cef_auth_callback_t* self,
                            const cef_string_t* username,
                            const cef_string_t* password);
 
   ///
-  // Cancel the authentication request.
+  /// Cancel the authentication request.
   ///
   void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self);
 } cef_auth_callback_t;

include/capi/cef_browser_process_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=ad0a78715daff99c1ec987800b7e5d62196e7100$
+// $hash=56ad161a75ca5083812e11959053abbcafbb9a5d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
@@ -43,6 +43,8 @@
 #include "include/capi/cef_base_capi.h"
 #include "include/capi/cef_client_capi.h"
 #include "include/capi/cef_command_line_capi.h"
+#include "include/capi/cef_preference_capi.h"
+#include "include/capi/cef_request_context_handler_capi.h"
 #include "include/capi/cef_values_capi.h"
 
 #ifdef __cplusplus
@@ -50,60 +52,121 @@ extern "C" {
 #endif
 
 ///
-// Structure used to implement browser process callbacks. The functions of this
-// structure will be called on the browser process main thread unless otherwise
-// indicated.
+/// Structure used to implement browser process callbacks. The functions of this
+/// structure will be called on the browser process main thread unless otherwise
+/// indicated.
 ///
 typedef struct _cef_browser_process_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called on the browser process UI thread immediately after the CEF context
-  // has been initialized.
+  /// Provides an opportunity to register custom preferences prior to global and
+  /// request context initialization.
+  ///
+  /// If |type| is CEF_PREFERENCES_TYPE_GLOBAL the registered preferences can be
+  /// accessed via cef_preference_manager_t::GetGlobalPreferences after
+  /// OnContextInitialized is called. Global preferences are registered a single
+  /// time at application startup. See related cef_settings_t.cache_path
+  /// configuration.
+  ///
+  /// If |type| is CEF_PREFERENCES_TYPE_REQUEST_CONTEXT the preferences can be
+  /// accessed via the cef_request_context_t after
+  /// cef_request_context_handler_t::OnRequestContextInitialized is called.
+  /// Request context preferences are registered each time a new
+  /// cef_request_context_t is created. It is intended but not required that all
+  /// request contexts have the same registered preferences. See related
+  /// cef_request_context_settings_t.cache_path configuration.
+  ///
+  /// Do not keep a reference to the |registrar| object. This function is called
+  /// on the browser process UI thread.
+  ///
+  void(CEF_CALLBACK* on_register_custom_preferences)(
+      struct _cef_browser_process_handler_t* self,
+      cef_preferences_type_t type,
+      struct _cef_preference_registrar_t* registrar);
+
+  ///
+  /// Called on the browser process UI thread immediately after the CEF context
+  /// has been initialized.
   ///
   void(CEF_CALLBACK* on_context_initialized)(
       struct _cef_browser_process_handler_t* self);
 
   ///
-  // Called before a child process is launched. Will be called on the browser
-  // process UI thread when launching a render process and on the browser
-  // process IO thread when launching a GPU process. Provides an opportunity to
-  // modify the child process command line. Do not keep a reference to
-  // |command_line| outside of this function.
+  /// Called before a child process is launched. Will be called on the browser
+  /// process UI thread when launching a render process and on the browser
+  /// process IO thread when launching a GPU process. Provides an opportunity to
+  /// modify the child process command line. Do not keep a reference to
+  /// |command_line| outside of this function.
   ///
   void(CEF_CALLBACK* on_before_child_process_launch)(
       struct _cef_browser_process_handler_t* self,
       struct _cef_command_line_t* command_line);
 
   ///
-  // Called from any thread when work has been scheduled for the browser process
-  // main (UI) thread. This callback is used in combination with CefSettings.
-  // external_message_pump and cef_do_message_loop_work() in cases where the CEF
-  // message loop must be integrated into an existing application message loop
-  // (see additional comments and warnings on CefDoMessageLoopWork). This
-  // callback should schedule a cef_do_message_loop_work() call to happen on the
-  // main (UI) thread. |delay_ms| is the requested delay in milliseconds. If
-  // |delay_ms| is <= 0 then the call should happen reasonably soon. If
-  // |delay_ms| is > 0 then the call should be scheduled to happen after the
-  // specified delay and any currently pending scheduled call should be
-  // cancelled.
+  /// Implement this function to provide app-specific behavior when an already
+  /// running app is relaunched with the same CefSettings.root_cache_path value.
+  /// For example, activate an existing app window or create a new app window.
+  /// |command_line| will be read-only. Do not keep a reference to
+  /// |command_line| outside of this function. Return true (1) if the relaunch
+  /// is handled or false (0) for default relaunch behavior. Default behavior
+  /// will create a new default styled Chrome window.
+  ///
+  /// To avoid cache corruption only a single app instance is allowed to run for
+  /// a given CefSettings.root_cache_path value. On relaunch the app checks a
+  /// process singleton lock and then forwards the new launch arguments to the
+  /// already running app process before exiting early. Client apps should
+  /// therefore check the cef_initialize() return value for early exit before
+  /// proceeding.
+  ///
+  /// This function will be called on the browser process UI thread.
+  ///
+  int(CEF_CALLBACK* on_already_running_app_relaunch)(
+      struct _cef_browser_process_handler_t* self,
+      struct _cef_command_line_t* command_line,
+      const cef_string_t* current_directory);
+
+  ///
+  /// Called from any thread when work has been scheduled for the browser
+  /// process main (UI) thread. This callback is used in combination with
+  /// cef_settings_t.external_message_pump and cef_do_message_loop_work() in
+  /// cases where the CEF message loop must be integrated into an existing
+  /// application message loop (see additional comments and warnings on
+  /// CefDoMessageLoopWork). This callback should schedule a
+  /// cef_do_message_loop_work() call to happen on the main (UI) thread.
+  /// |delay_ms| is the requested delay in milliseconds. If |delay_ms| is <= 0
+  /// then the call should happen reasonably soon. If |delay_ms| is > 0 then the
+  /// call should be scheduled to happen after the specified delay and any
+  /// currently pending scheduled call should be cancelled.
   ///
   void(CEF_CALLBACK* on_schedule_message_pump_work)(
       struct _cef_browser_process_handler_t* self,
-      int64 delay_ms);
+      int64_t delay_ms);
 
   ///
-  // Return the default client for use with a newly created browser window. If
-  // null is returned the browser will be unmanaged (no callbacks will be
-  // executed for that browser) and application shutdown will be blocked until
-  // the browser window is closed manually. This function is currently only used
-  // with the chrome runtime.
+  /// Return the default client for use with a newly created browser window
+  /// (cef_browser_t object). If null is returned the cef_browser_t will be
+  /// unmanaged (no callbacks will be executed for that cef_browser_t) and
+  /// application shutdown will be blocked until the browser window is closed
+  /// manually. This function is currently only used with Chrome style when
+  /// creating new browser windows via Chrome UI.
   ///
   struct _cef_client_t*(CEF_CALLBACK* get_default_client)(
       struct _cef_browser_process_handler_t* self);
+
+  ///
+  /// Return the default handler for use with a new user or incognito profile
+  /// (cef_request_context_t object). If null is returned the
+  /// cef_request_context_t will be unmanaged (no callbacks will be executed for
+  /// that cef_request_context_t). This function is currently only used with
+  /// Chrome style when creating new browser windows via Chrome UI.
+  ///
+  struct _cef_request_context_handler_t*(
+      CEF_CALLBACK* get_default_request_context_handler)(
+      struct _cef_browser_process_handler_t* self);
 } cef_browser_process_handler_t;
 
 #ifdef __cplusplus

include/capi/cef_callback_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=10ef5088ce2a5c6ffb38f8864d3aad6e5ac88b40$
+// $hash=46bc048bec64590735298a95633167d66e445844$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
@@ -47,36 +47,36 @@ extern "C" {
 #endif
 
 ///
-// Generic callback structure used for asynchronous continuation.
+/// Generic callback structure used for asynchronous continuation.
 ///
 typedef struct _cef_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Continue processing.
+  /// Continue processing.
   ///
   void(CEF_CALLBACK* cont)(struct _cef_callback_t* self);
 
   ///
-  // Cancel processing.
+  /// Cancel processing.
   ///
   void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self);
 } cef_callback_t;
 
 ///
-// Generic callback structure used for asynchronous completion.
+/// Generic callback structure used for asynchronous completion.
 ///
 typedef struct _cef_completion_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method that will be called once the task is complete.
+  /// Method that will be called once the task is complete.
   ///
   void(CEF_CALLBACK* on_complete)(struct _cef_completion_callback_t* self);
 } cef_completion_callback_t;

include/capi/cef_client_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=8b099ca3b9cfbd41840cdf64586a0b884abaffae$
+// $hash=09bd4140605645c9dfbd81e7e22d029d0bb50129$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@@ -42,6 +42,7 @@
 
 #include "include/capi/cef_audio_handler_capi.h"
 #include "include/capi/cef_base_capi.h"
+#include "include/capi/cef_command_handler_capi.h"
 #include "include/capi/cef_context_menu_handler_capi.h"
 #include "include/capi/cef_dialog_handler_capi.h"
 #include "include/capi/cef_display_handler_capi.h"
@@ -54,6 +55,7 @@
 #include "include/capi/cef_keyboard_handler_capi.h"
 #include "include/capi/cef_life_span_handler_capi.h"
 #include "include/capi/cef_load_handler_capi.h"
+#include "include/capi/cef_permission_handler_capi.h"
 #include "include/capi/cef_print_handler_capi.h"
 #include "include/capi/cef_process_message_capi.h"
 #include "include/capi/cef_render_handler_capi.h"
@@ -64,121 +66,134 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to provide handler implementations.
+/// Implement this structure to provide handler implementations.
 ///
 typedef struct _cef_client_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Return the handler for audio rendering events.
+  /// Return the handler for audio rendering events.
   ///
   struct _cef_audio_handler_t*(CEF_CALLBACK* get_audio_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for context menus. If no handler is provided the default
-  // implementation will be used.
+  /// Return the handler for commands. If no handler is provided the default
+  /// implementation will be used.
+  ///
+  struct _cef_command_handler_t*(CEF_CALLBACK* get_command_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  /// Return the handler for context menus. If no handler is provided the
+  /// default implementation will be used.
   ///
   struct _cef_context_menu_handler_t*(CEF_CALLBACK* get_context_menu_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for dialogs. If no handler is provided the default
-  // implementation will be used.
+  /// Return the handler for dialogs. If no handler is provided the default
+  /// implementation will be used.
   ///
   struct _cef_dialog_handler_t*(CEF_CALLBACK* get_dialog_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for browser display state events.
+  /// Return the handler for browser display state events.
   ///
   struct _cef_display_handler_t*(CEF_CALLBACK* get_display_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for download events. If no handler is returned downloads
-  // will not be allowed.
+  /// Return the handler for download events. If no handler is returned
+  /// downloads will not be allowed.
   ///
   struct _cef_download_handler_t*(CEF_CALLBACK* get_download_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for drag events.
+  /// Return the handler for drag events.
   ///
   struct _cef_drag_handler_t*(CEF_CALLBACK* get_drag_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for find result events.
+  /// Return the handler for find result events.
   ///
   struct _cef_find_handler_t*(CEF_CALLBACK* get_find_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for focus events.
+  /// Return the handler for focus events.
   ///
   struct _cef_focus_handler_t*(CEF_CALLBACK* get_focus_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for events related to cef_frame_t lifespan. This
-  // function will be called once during cef_browser_t creation and the result
-  // will be cached for performance reasons.
+  /// Return the handler for events related to cef_frame_t lifespan. This
+  /// function will be called once during cef_browser_t creation and the result
+  /// will be cached for performance reasons.
   ///
   struct _cef_frame_handler_t*(CEF_CALLBACK* get_frame_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for JavaScript dialogs. If no handler is provided the
-  // default implementation will be used.
+  /// Return the handler for permission requests.
+  ///
+  struct _cef_permission_handler_t*(CEF_CALLBACK* get_permission_handler)(
+      struct _cef_client_t* self);
+
+  ///
+  /// Return the handler for JavaScript dialogs. If no handler is provided the
+  /// default implementation will be used.
   ///
   struct _cef_jsdialog_handler_t*(CEF_CALLBACK* get_jsdialog_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for keyboard events.
+  /// Return the handler for keyboard events.
   ///
   struct _cef_keyboard_handler_t*(CEF_CALLBACK* get_keyboard_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for browser life span events.
+  /// Return the handler for browser life span events.
   ///
   struct _cef_life_span_handler_t*(CEF_CALLBACK* get_life_span_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for browser load status events.
+  /// Return the handler for browser load status events.
   ///
   struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for printing on Linux. If a print handler is not
-  // provided then printing will not be supported on the Linux platform.
+  /// Return the handler for printing on Linux. If a print handler is not
+  /// provided then printing will not be supported on the Linux platform.
   ///
   struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for off-screen rendering events.
+  /// Return the handler for off-screen rendering events.
   ///
   struct _cef_render_handler_t*(CEF_CALLBACK* get_render_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Return the handler for browser request events.
+  /// Return the handler for browser request events.
   ///
   struct _cef_request_handler_t*(CEF_CALLBACK* get_request_handler)(
       struct _cef_client_t* self);
 
   ///
-  // Called when a new message is received from a different process. Return true
-  // (1) if the message was handled or false (0) otherwise.  It is safe to keep
-  // a reference to |message| outside of this callback.
+  /// Called when a new message is received from a different process. Return
+  /// true (1) if the message was handled or false (0) otherwise.  It is safe to
+  /// keep a reference to |message| outside of this callback.
   ///
   int(CEF_CALLBACK* on_process_message_received)(
       struct _cef_client_t* self,

include/capi/cef_command_handler_capi.h

@@ -0,0 +1,118 @@
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=9c7d613d1256bd6353f5102ece5a04e572f20627$
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_
+#pragma once
+
+#include "include/capi/cef_base_capi.h"
+#include "include/capi/cef_browser_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+/// Implement this structure to handle events related to commands. The functions
+/// of this structure will be called on the UI thread.
+///
+typedef struct _cef_command_handler_t {
+  ///
+  /// Base structure.
+  ///
+  cef_base_ref_counted_t base;
+
+  ///
+  /// Called to execute a Chrome command triggered via menu selection or
+  /// keyboard shortcut. Values for |command_id| can be found in the
+  /// cef_command_ids.h file. |disposition| provides information about the
+  /// intended command target. Return true (1) if the command was handled or
+  /// false (0) for the default implementation. For context menu commands this
+  /// will be called after cef_context_menu_handler_t::OnContextMenuCommand.
+  /// Only used with Chrome style.
+  ///
+  int(CEF_CALLBACK* on_chrome_command)(
+      struct _cef_command_handler_t* self,
+      struct _cef_browser_t* browser,
+      int command_id,
+      cef_window_open_disposition_t disposition);
+
+  ///
+  /// Called to check if a Chrome app menu item should be visible. Values for
+  /// |command_id| can be found in the cef_command_ids.h file. Only called for
+  /// menu items that would be visible by default. Only used with Chrome style.
+  ///
+  int(CEF_CALLBACK* is_chrome_app_menu_item_visible)(
+      struct _cef_command_handler_t* self,
+      struct _cef_browser_t* browser,
+      int command_id);
+
+  ///
+  /// Called to check if a Chrome app menu item should be enabled. Values for
+  /// |command_id| can be found in the cef_command_ids.h file. Only called for
+  /// menu items that would be enabled by default. Only used with Chrome style.
+  ///
+  int(CEF_CALLBACK* is_chrome_app_menu_item_enabled)(
+      struct _cef_command_handler_t* self,
+      struct _cef_browser_t* browser,
+      int command_id);
+
+  ///
+  /// Called during browser creation to check if a Chrome page action icon
+  /// should be visible. Only called for icons that would be visible by default.
+  /// Only used with Chrome style.
+  ///
+  int(CEF_CALLBACK* is_chrome_page_action_icon_visible)(
+      struct _cef_command_handler_t* self,
+      cef_chrome_page_action_icon_type_t icon_type);
+
+  ///
+  /// Called during browser creation to check if a Chrome toolbar button should
+  /// be visible. Only called for buttons that would be visible by default. Only
+  /// used with Chrome style.
+  ///
+  int(CEF_CALLBACK* is_chrome_toolbar_button_visible)(
+      struct _cef_command_handler_t* self,
+      cef_chrome_toolbar_button_type_t button_type);
+} cef_command_handler_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_

include/capi/cef_command_line_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=3049c9960a95d32d61cc57ae998c0eba12820673$
+// $hash=fce786b3f054d6581438e2906b77e573c797372a$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
@@ -47,104 +47,104 @@ extern "C" {
 #endif
 
 ///
-// Structure used to create and/or parse command line arguments. Arguments with
-// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
-// will always precede any arguments without switch prefixes. Switches can
-// optionally have a value specified using the '=' delimiter (e.g.
-// "-switch=value"). An argument of "--" will terminate switch parsing with all
-// subsequent tokens, regardless of prefix, being interpreted as non-switch
-// arguments. Switch names should be lowercase ASCII and will be converted to
-// such if necessary. Switch values will retain the original case and UTF8
-// encoding. This structure can be used before cef_initialize() is called.
+/// Structure used to create and/or parse command line arguments. Arguments with
+/// "--", "-" and, on Windows, "/" prefixes are considered switches. Switches
+/// will always precede any arguments without switch prefixes. Switches can
+/// optionally have a value specified using the "=" delimiter (e.g.
+/// "-switch=value"). An argument of "--" will terminate switch parsing with all
+/// subsequent tokens, regardless of prefix, being interpreted as non-switch
+/// arguments. Switch names should be lowercase ASCII and will be converted to
+/// such if necessary. Switch values will retain the original case and UTF8
+/// encoding. This structure can be used before cef_initialize() is called.
 ///
 typedef struct _cef_command_line_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns true (1) if this object is valid. Do not call any other functions
-  // if this function returns false (0).
+  /// Returns true (1) if this object is valid. Do not call any other functions
+  /// if this function returns false (0).
   ///
   int(CEF_CALLBACK* is_valid)(struct _cef_command_line_t* self);
 
   ///
-  // Returns true (1) if the values of this object are read-only. Some APIs may
-  // expose read-only objects.
+  /// Returns true (1) if the values of this object are read-only. Some APIs may
+  /// expose read-only objects.
   ///
   int(CEF_CALLBACK* is_read_only)(struct _cef_command_line_t* self);
 
   ///
-  // Returns a writable copy of this object.
+  /// Returns a writable copy of this object.
   ///
   struct _cef_command_line_t*(CEF_CALLBACK* copy)(
       struct _cef_command_line_t* self);
 
   ///
-  // Initialize the command line with the specified |argc| and |argv| values.
-  // The first argument must be the name of the program. This function is only
-  // supported on non-Windows platforms.
+  /// Initialize the command line with the specified |argc| and |argv| values.
+  /// The first argument must be the name of the program. This function is only
+  /// supported on non-Windows platforms.
   ///
   void(CEF_CALLBACK* init_from_argv)(struct _cef_command_line_t* self,
                                      int argc,
                                      const char* const* argv);
 
   ///
-  // Initialize the command line with the string returned by calling
-  // GetCommandLineW(). This function is only supported on Windows.
+  /// Initialize the command line with the string returned by calling
+  /// GetCommandLineW(). This function is only supported on Windows.
   ///
   void(CEF_CALLBACK* init_from_string)(struct _cef_command_line_t* self,
                                        const cef_string_t* command_line);
 
   ///
-  // Reset the command-line switches and arguments but leave the program
-  // component unchanged.
+  /// Reset the command-line switches and arguments but leave the program
+  /// component unchanged.
   ///
   void(CEF_CALLBACK* reset)(struct _cef_command_line_t* self);
 
   ///
-  // Retrieve the original command line string as a vector of strings. The argv
-  // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  /// Retrieve the original command line string as a vector of strings. The argv
+  /// array: `{ program, [(--|-|/)switch[=value]]*, [--], [argument]* }`
   ///
   void(CEF_CALLBACK* get_argv)(struct _cef_command_line_t* self,
                                cef_string_list_t argv);
 
   ///
-  // Constructs and returns the represented command line string. Use this
-  // function cautiously because quoting behavior is unclear.
+  /// Constructs and returns the represented command line string. Use this
+  /// function cautiously because quoting behavior is unclear.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_command_line_string)(
       struct _cef_command_line_t* self);
 
   ///
-  // Get the program part of the command line string (the first item).
+  /// Get the program part of the command line string (the first item).
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_program)(
       struct _cef_command_line_t* self);
 
   ///
-  // Set the program part of the command line string (the first item).
+  /// Set the program part of the command line string (the first item).
   ///
   void(CEF_CALLBACK* set_program)(struct _cef_command_line_t* self,
                                   const cef_string_t* program);
 
   ///
-  // Returns true (1) if the command line has switches.
+  /// Returns true (1) if the command line has switches.
   ///
   int(CEF_CALLBACK* has_switches)(struct _cef_command_line_t* self);
 
   ///
-  // Returns true (1) if the command line contains the given switch.
+  /// Returns true (1) if the command line contains the given switch.
   ///
   int(CEF_CALLBACK* has_switch)(struct _cef_command_line_t* self,
                                 const cef_string_t* name);
 
   ///
-  // Returns the value associated with the given switch. If the switch has no
-  // value or isn't present this function returns the NULL string.
+  /// Returns the value associated with the given switch. If the switch has no
+  /// value or isn't present this function returns the NULL string.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_switch_value)(
@@ -152,59 +152,59 @@ typedef struct _cef_command_line_t {
       const cef_string_t* name);
 
   ///
-  // Returns the map of switch names and values. If a switch has no value an
-  // NULL string is returned.
+  /// Returns the map of switch names and values. If a switch has no value an
+  /// NULL string is returned.
   ///
   void(CEF_CALLBACK* get_switches)(struct _cef_command_line_t* self,
                                    cef_string_map_t switches);
 
   ///
-  // Add a switch to the end of the command line. If the switch has no value
-  // pass an NULL value string.
+  /// Add a switch to the end of the command line.
   ///
   void(CEF_CALLBACK* append_switch)(struct _cef_command_line_t* self,
                                     const cef_string_t* name);
 
   ///
-  // Add a switch with the specified value to the end of the command line.
+  /// Add a switch with the specified value to the end of the command line. If
+  /// the switch has no value pass an NULL value string.
   ///
   void(CEF_CALLBACK* append_switch_with_value)(struct _cef_command_line_t* self,
                                                const cef_string_t* name,
                                                const cef_string_t* value);
 
   ///
-  // True if there are remaining command line arguments.
+  /// True if there are remaining command line arguments.
   ///
   int(CEF_CALLBACK* has_arguments)(struct _cef_command_line_t* self);
 
   ///
-  // Get the remaining command line arguments.
+  /// Get the remaining command line arguments.
   ///
   void(CEF_CALLBACK* get_arguments)(struct _cef_command_line_t* self,
                                     cef_string_list_t arguments);
 
   ///
-  // Add an argument to the end of the command line.
+  /// Add an argument to the end of the command line.
   ///
   void(CEF_CALLBACK* append_argument)(struct _cef_command_line_t* self,
                                       const cef_string_t* argument);
 
   ///
-  // Insert a command before the current command. Common for debuggers, like
-  // "valgrind" or "gdb --args".
+  /// Insert a command before the current command. Common for debuggers, like
+  /// "valgrind" or "gdb --args".
   ///
   void(CEF_CALLBACK* prepend_wrapper)(struct _cef_command_line_t* self,
                                       const cef_string_t* wrapper);
 } cef_command_line_t;
 
 ///
-// Create a new cef_command_line_t instance.
+/// Create a new cef_command_line_t instance.
 ///
 CEF_EXPORT cef_command_line_t* cef_command_line_create(void);
 
 ///
-// Returns the singleton global cef_command_line_t object. The returned object
-// will be read-only.
+/// Returns the singleton global cef_command_line_t object. The returned object
+/// will be read-only.
 ///
 CEF_EXPORT cef_command_line_t* cef_command_line_get_global(void);
 

include/capi/cef_context_menu_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d007b3dc26f3f049bf67623da8fae59dc75a193b$
+// $hash=3ae7dbb24ec7a95a2f4d4e390c9b6622221c2f42$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@@ -52,44 +52,67 @@ extern "C" {
 struct _cef_context_menu_params_t;
 
 ///
-// Callback structure used for continuation of custom context menu display.
+/// Callback structure used for continuation of custom context menu display.
 ///
 typedef struct _cef_run_context_menu_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Complete context menu display by selecting the specified |command_id| and
-  // |event_flags|.
+  /// Complete context menu display by selecting the specified |command_id| and
+  /// |event_flags|.
   ///
   void(CEF_CALLBACK* cont)(struct _cef_run_context_menu_callback_t* self,
                            int command_id,
                            cef_event_flags_t event_flags);
 
   ///
-  // Cancel context menu display.
+  /// Cancel context menu display.
   ///
   void(CEF_CALLBACK* cancel)(struct _cef_run_context_menu_callback_t* self);
 } cef_run_context_menu_callback_t;
 
 ///
-// Implement this structure to handle context menu events. The functions of this
-// structure will be called on the UI thread.
+/// Callback structure used for continuation of custom quick menu display.
 ///
-typedef struct _cef_context_menu_handler_t {
+typedef struct _cef_run_quick_menu_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called before a context menu is displayed. |params| provides information
-  // about the context menu state. |model| initially contains the default
-  // context menu. The |model| can be cleared to show no context menu or
-  // modified to show a custom menu. Do not keep references to |params| or
-  // |model| outside of this callback.
+  /// Complete quick menu display by selecting the specified |command_id| and
+  /// |event_flags|.
+  ///
+  void(CEF_CALLBACK* cont)(struct _cef_run_quick_menu_callback_t* self,
+                           int command_id,
+                           cef_event_flags_t event_flags);
+
+  ///
+  /// Cancel quick menu display.
+  ///
+  void(CEF_CALLBACK* cancel)(struct _cef_run_quick_menu_callback_t* self);
+} cef_run_quick_menu_callback_t;
+
+///
+/// Implement this structure to handle context menu events. The functions of
+/// this structure will be called on the UI thread.
+///
+typedef struct _cef_context_menu_handler_t {
+  ///
+  /// Base structure.
+  ///
+  cef_base_ref_counted_t base;
+
+  ///
+  /// Called before a context menu is displayed. |params| provides information
+  /// about the context menu state. |model| initially contains the default
+  /// context menu. The |model| can be cleared to show no context menu or
+  /// modified to show a custom menu. Do not keep references to |params| or
+  /// |model| outside of this callback.
   ///
   void(CEF_CALLBACK* on_before_context_menu)(
       struct _cef_context_menu_handler_t* self,
@@ -99,12 +122,12 @@ typedef struct _cef_context_menu_handler_t {
       struct _cef_menu_model_t* model);
 
   ///
-  // Called to allow custom display of the context menu. |params| provides
-  // information about the context menu state. |model| contains the context menu
-  // model resulting from OnBeforeContextMenu. For custom display return true
-  // (1) and execute |callback| either synchronously or asynchronously with the
-  // selected command ID. For default display return false (0). Do not keep
-  // references to |params| or |model| outside of this callback.
+  /// Called to allow custom display of the context menu. |params| provides
+  /// information about the context menu state. |model| contains the context
+  /// menu model resulting from OnBeforeContextMenu. For custom display return
+  /// true (1) and execute |callback| either synchronously or asynchronously
+  /// with the selected command ID. For default display return false (0). Do not
+  /// keep references to |params| or |model| outside of this callback.
   ///
   int(CEF_CALLBACK* run_context_menu)(
       struct _cef_context_menu_handler_t* self,
@@ -115,13 +138,13 @@ typedef struct _cef_context_menu_handler_t {
       struct _cef_run_context_menu_callback_t* callback);
 
   ///
-  // Called to execute a command selected from the context menu. Return true (1)
-  // if the command was handled or false (0) for the default implementation. See
-  // cef_menu_id_t for the command ids that have default implementations. All
-  // user-defined command ids should be between MENU_ID_USER_FIRST and
-  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
-  // on_before_context_menu(). Do not keep a reference to |params| outside of
-  // this callback.
+  /// Called to execute a command selected from the context menu. Return true
+  /// (1) if the command was handled or false (0) for the default
+  /// implementation. See cef_menu_id_t for the command ids that have default
+  /// implementations. All user-defined command ids should be between
+  /// MENU_ID_USER_FIRST and MENU_ID_USER_LAST. |params| will have the same
+  /// values as what was passed to on_before_context_menu(). Do not keep a
+  /// reference to |params| outside of this callback.
   ///
   int(CEF_CALLBACK* on_context_menu_command)(
       struct _cef_context_menu_handler_t* self,
@@ -132,165 +155,207 @@ typedef struct _cef_context_menu_handler_t {
       cef_event_flags_t event_flags);
 
   ///
-  // Called when the context menu is dismissed irregardless of whether the menu
-  // was NULL or a command was selected.
+  /// Called when the context menu is dismissed irregardless of whether the menu
+  /// was canceled or a command was selected.
   ///
   void(CEF_CALLBACK* on_context_menu_dismissed)(
       struct _cef_context_menu_handler_t* self,
       struct _cef_browser_t* browser,
       struct _cef_frame_t* frame);
+
+  ///
+  /// Called to allow custom display of the quick menu for a windowless browser.
+  /// |location| is the top left corner of the selected region. |size| is the
+  /// size of the selected region. |edit_state_flags| is a combination of flags
+  /// that represent the state of the quick menu. Return true (1) if the menu
+  /// will be handled and execute |callback| either synchronously or
+  /// asynchronously with the selected command ID. Return false (0) to cancel
+  /// the menu.
+  ///
+  int(CEF_CALLBACK* run_quick_menu)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      const cef_point_t* location,
+      const cef_size_t* size,
+      cef_quick_menu_edit_state_flags_t edit_state_flags,
+      struct _cef_run_quick_menu_callback_t* callback);
+
+  ///
+  /// Called to execute a command selected from the quick menu for a windowless
+  /// browser. Return true (1) if the command was handled or false (0) for the
+  /// default implementation. See cef_menu_id_t for command IDs that have
+  /// default implementations.
+  ///
+  int(CEF_CALLBACK* on_quick_menu_command)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      int command_id,
+      cef_event_flags_t event_flags);
+
+  ///
+  /// Called when the quick menu for a windowless browser is dismissed
+  /// irregardless of whether the menu was canceled or a command was selected.
+  ///
+  void(CEF_CALLBACK* on_quick_menu_dismissed)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame);
 } cef_context_menu_handler_t;
 
 ///
-// Provides information about the context menu state. The ethods of this
-// structure can only be accessed on browser process the UI thread.
+/// Provides information about the context menu state. The functions of this
+/// structure can only be accessed on browser process the UI thread.
 ///
 typedef struct _cef_context_menu_params_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns the X coordinate of the mouse where the context menu was invoked.
-  // Coords are relative to the associated RenderView's origin.
+  /// Returns the X coordinate of the mouse where the context menu was invoked.
+  /// Coords are relative to the associated RenderView's origin.
   ///
   int(CEF_CALLBACK* get_xcoord)(struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the Y coordinate of the mouse where the context menu was invoked.
-  // Coords are relative to the associated RenderView's origin.
+  /// Returns the Y coordinate of the mouse where the context menu was invoked.
+  /// Coords are relative to the associated RenderView's origin.
   ///
   int(CEF_CALLBACK* get_ycoord)(struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns flags representing the type of node that the context menu was
-  // invoked on.
+  /// Returns flags representing the type of node that the context menu was
+  /// invoked on.
   ///
   cef_context_menu_type_flags_t(CEF_CALLBACK* get_type_flags)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the URL of the link, if any, that encloses the node that the
-  // context menu was invoked on.
+  /// Returns the URL of the link, if any, that encloses the node that the
+  /// context menu was invoked on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_link_url)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the link URL, if any, to be used ONLY for "copy link address". We
-  // don't validate this field in the frontend process.
+  /// Returns the link URL, if any, to be used ONLY for "copy link address". We
+  /// don't validate this field in the frontend process.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_unfiltered_link_url)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the source URL, if any, for the element that the context menu was
-  // invoked on. Example of elements with source URLs are img, audio, and video.
+  /// Returns the source URL, if any, for the element that the context menu was
+  /// invoked on. Example of elements with source URLs are img, audio, and
+  /// video.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_source_url)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns true (1) if the context menu was invoked on an image which has non-
-  // NULL contents.
+  /// Returns true (1) if the context menu was invoked on an image which has
+  /// non-NULL contents.
   ///
   int(CEF_CALLBACK* has_image_contents)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the title text or the alt text if the context menu was invoked on
-  // an image.
+  /// Returns the title text or the alt text if the context menu was invoked on
+  /// an image.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_title_text)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the URL of the top level page that the context menu was invoked on.
+  /// Returns the URL of the top level page that the context menu was invoked
+  /// on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_page_url)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the URL of the subframe that the context menu was invoked on.
+  /// Returns the URL of the subframe that the context menu was invoked on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_frame_url)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the character encoding of the subframe that the context menu was
-  // invoked on.
+  /// Returns the character encoding of the subframe that the context menu was
+  /// invoked on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_frame_charset)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the type of context node that the context menu was invoked on.
+  /// Returns the type of context node that the context menu was invoked on.
   ///
   cef_context_menu_media_type_t(CEF_CALLBACK* get_media_type)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns flags representing the actions supported by the media element, if
-  // any, that the context menu was invoked on.
+  /// Returns flags representing the actions supported by the media element, if
+  /// any, that the context menu was invoked on.
   ///
   cef_context_menu_media_state_flags_t(CEF_CALLBACK* get_media_state_flags)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the text of the selection, if any, that the context menu was
-  // invoked on.
+  /// Returns the text of the selection, if any, that the context menu was
+  /// invoked on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_selection_text)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns the text of the misspelled word, if any, that the context menu was
-  // invoked on.
+  /// Returns the text of the misspelled word, if any, that the context menu was
+  /// invoked on.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_misspelled_word)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns true (1) if suggestions exist, false (0) otherwise. Fills in
-  // |suggestions| from the spell check service for the misspelled word if there
-  // is one.
+  /// Returns true (1) if suggestions exist, false (0) otherwise. Fills in
+  /// |suggestions| from the spell check service for the misspelled word if
+  /// there is one.
   ///
   int(CEF_CALLBACK* get_dictionary_suggestions)(
       struct _cef_context_menu_params_t* self,
       cef_string_list_t suggestions);
 
   ///
-  // Returns true (1) if the context menu was invoked on an editable node.
+  /// Returns true (1) if the context menu was invoked on an editable node.
   ///
   int(CEF_CALLBACK* is_editable)(struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns true (1) if the context menu was invoked on an editable node where
-  // spell-check is enabled.
+  /// Returns true (1) if the context menu was invoked on an editable node where
+  /// spell-check is enabled.
   ///
   int(CEF_CALLBACK* is_spell_check_enabled)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns flags representing the actions supported by the editable node, if
-  // any, that the context menu was invoked on.
+  /// Returns flags representing the actions supported by the editable node, if
+  /// any, that the context menu was invoked on.
   ///
   cef_context_menu_edit_state_flags_t(CEF_CALLBACK* get_edit_state_flags)(
       struct _cef_context_menu_params_t* self);
 
   ///
-  // Returns true (1) if the context menu contains items specified by the
-  // renderer process.
+  /// Returns true (1) if the context menu contains items specified by the
+  /// renderer process.
   ///
   int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self);
 } cef_context_menu_params_t;

include/capi/cef_cookie_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d9790a35d74621e985b917935a4fca74ba7db1e0$
+// $hash=76ba2e59636aa71c8c6286093198a1e64d012c62$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
@@ -52,29 +52,29 @@ struct _cef_delete_cookies_callback_t;
 struct _cef_set_cookie_callback_t;
 
 ///
-// Structure used for managing cookies. The functions of this structure may be
-// called on any thread unless otherwise indicated.
+/// Structure used for managing cookies. The functions of this structure may be
+/// called on any thread unless otherwise indicated.
 ///
 typedef struct _cef_cookie_manager_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Visit all cookies on the UI thread. The returned cookies are ordered by
-  // longest path, then by earliest creation date. Returns false (0) if cookies
-  // cannot be accessed.
+  /// Visit all cookies on the UI thread. The returned cookies are ordered by
+  /// longest path, then by earliest creation date. Returns false (0) if cookies
+  /// cannot be accessed.
   ///
   int(CEF_CALLBACK* visit_all_cookies)(struct _cef_cookie_manager_t* self,
                                        struct _cef_cookie_visitor_t* visitor);
 
   ///
-  // Visit a subset of cookies on the UI thread. The results are filtered by the
-  // given url scheme, host, domain and path. If |includeHttpOnly| is true (1)
-  // HTTP-only cookies will also be included in the results. The returned
-  // cookies are ordered by longest path, then by earliest creation date.
-  // Returns false (0) if cookies cannot be accessed.
+  /// Visit a subset of cookies on the UI thread. The results are filtered by
+  /// the given url scheme, host, domain and path. If |includeHttpOnly| is true
+  /// (1) HTTP-only cookies will also be included in the results. The returned
+  /// cookies are ordered by longest path, then by earliest creation date.
+  /// Returns false (0) if cookies cannot be accessed.
   ///
   int(CEF_CALLBACK* visit_url_cookies)(struct _cef_cookie_manager_t* self,
                                        const cef_string_t* url,
@@ -82,13 +82,13 @@ typedef struct _cef_cookie_manager_t {
                                        struct _cef_cookie_visitor_t* visitor);
 
   ///
-  // Sets a cookie given a valid URL and explicit user-provided cookie
-  // attributes. This function expects each attribute to be well-formed. It will
-  // check for disallowed characters (e.g. the ';' character is disallowed
-  // within the cookie value attribute) and fail without setting the cookie if
-  // such characters are found. If |callback| is non-NULL it will be executed
-  // asnychronously on the UI thread after the cookie has been set. Returns
-  // false (0) if an invalid URL is specified or if cookies cannot be accessed.
+  /// Sets a cookie given a valid URL and explicit user-provided cookie
+  /// attributes. This function expects each attribute to be well-formed. It
+  /// will check for disallowed characters (e.g. the ';' character is disallowed
+  /// within the cookie value attribute) and fail without setting the cookie if
+  /// such characters are found. If |callback| is non-NULL it will be executed
+  /// asnychronously on the UI thread after the cookie has been set. Returns
+  /// false (0) if an invalid URL is specified or if cookies cannot be accessed.
   ///
   int(CEF_CALLBACK* set_cookie)(struct _cef_cookie_manager_t* self,
                                 const cef_string_t* url,
@@ -96,15 +96,15 @@ typedef struct _cef_cookie_manager_t {
                                 struct _cef_set_cookie_callback_t* callback);
 
   ///
-  // Delete all cookies that match the specified parameters. If both |url| and
-  // |cookie_name| values are specified all host and domain cookies matching
-  // both will be deleted. If only |url| is specified all host cookies (but not
-  // domain cookies) irrespective of path will be deleted. If |url| is NULL all
-  // cookies for all hosts and domains will be deleted. If |callback| is non-
-  // NULL it will be executed asnychronously on the UI thread after the cookies
-  // have been deleted. Returns false (0) if a non-NULL invalid URL is specified
-  // or if cookies cannot be accessed. Cookies can alternately be deleted using
-  // the Visit*Cookies() functions.
+  /// Delete all cookies that match the specified parameters. If both |url| and
+  /// |cookie_name| values are specified all host and domain cookies matching
+  /// both will be deleted. If only |url| is specified all host cookies (but not
+  /// domain cookies) irrespective of path will be deleted. If |url| is NULL all
+  /// cookies for all hosts and domains will be deleted. If |callback| is non-
+  /// NULL it will be executed asnychronously on the UI thread after the cookies
+  /// have been deleted. Returns false (0) if a non-NULL invalid URL is
+  /// specified or if cookies cannot be accessed. Cookies can alternately be
+  /// deleted using the Visit*Cookies() functions.
   ///
   int(CEF_CALLBACK* delete_cookies)(
       struct _cef_cookie_manager_t* self,
@@ -113,41 +113,41 @@ typedef struct _cef_cookie_manager_t {
       struct _cef_delete_cookies_callback_t* callback);
 
   ///
-  // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
-  // be executed asnychronously on the UI thread after the flush is complete.
-  // Returns false (0) if cookies cannot be accessed.
+  /// Flush the backing store (if any) to disk. If |callback| is non-NULL it
+  /// will be executed asnychronously on the UI thread after the flush is
+  /// complete. Returns false (0) if cookies cannot be accessed.
   ///
   int(CEF_CALLBACK* flush_store)(struct _cef_cookie_manager_t* self,
                                  struct _cef_completion_callback_t* callback);
 } cef_cookie_manager_t;
 
 ///
-// Returns the global cookie manager. By default data will be stored at
-// CefSettings.cache_path if specified or in memory otherwise. If |callback| is
-// non-NULL it will be executed asnychronously on the UI thread after the
-// manager's storage has been initialized. Using this function is equivalent to
-// calling cef_request_context_t::cef_request_context_get_global_context()->GetD
-// efaultCookieManager().
+/// Returns the global cookie manager. By default data will be stored at
+/// cef_settings_t.cache_path if specified or in memory otherwise. If |callback|
+/// is non-NULL it will be executed asnychronously on the UI thread after the
+/// manager's storage has been initialized. Using this function is equivalent to
+/// calling cef_request_context_t::cef_request_context_get_global_context()-
+/// >GetDefaultCookieManager().
 ///
 CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(
     struct _cef_completion_callback_t* callback);
 
 ///
-// Structure to implement for visiting cookie values. The functions of this
-// structure will always be called on the UI thread.
+/// Structure to implement for visiting cookie values. The functions of this
+/// structure will always be called on the UI thread.
 ///
 typedef struct _cef_cookie_visitor_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method that will be called once for each cookie. |count| is the 0-based
-  // index for the current cookie. |total| is the total number of cookies. Set
-  // |deleteCookie| to true (1) to delete the cookie currently being visited.
-  // Return false (0) to stop visiting cookies. This function may never be
-  // called if no cookies are found.
+  /// Method that will be called once for each cookie. |count| is the 0-based
+  /// index for the current cookie. |total| is the total number of cookies. Set
+  /// |deleteCookie| to true (1) to delete the cookie currently being visited.
+  /// Return false (0) to stop visiting cookies. This function may never be
+  /// called if no cookies are found.
   ///
   int(CEF_CALLBACK* visit)(struct _cef_cookie_visitor_t* self,
                            const struct _cef_cookie_t* cookie,
@@ -157,36 +157,36 @@ typedef struct _cef_cookie_visitor_t {
 } cef_cookie_visitor_t;
 
 ///
-// Structure to implement to be notified of asynchronous completion via
-// cef_cookie_manager_t::set_cookie().
+/// Structure to implement to be notified of asynchronous completion via
+/// cef_cookie_manager_t::set_cookie().
 ///
 typedef struct _cef_set_cookie_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method that will be called upon completion. |success| will be true (1) if
-  // the cookie was set successfully.
+  /// Method that will be called upon completion. |success| will be true (1) if
+  /// the cookie was set successfully.
   ///
   void(CEF_CALLBACK* on_complete)(struct _cef_set_cookie_callback_t* self,
                                   int success);
 } cef_set_cookie_callback_t;
 
 ///
-// Structure to implement to be notified of asynchronous completion via
-// cef_cookie_manager_t::delete_cookies().
+/// Structure to implement to be notified of asynchronous completion via
+/// cef_cookie_manager_t::delete_cookies().
 ///
 typedef struct _cef_delete_cookies_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method that will be called upon completion. |num_deleted| will be the
-  // number of cookies that were deleted.
+  /// Method that will be called upon completion. |num_deleted| will be the
+  /// number of cookies that were deleted.
   ///
   void(CEF_CALLBACK* on_complete)(struct _cef_delete_cookies_callback_t* self,
                                   int num_deleted);

include/capi/cef_crash_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5d111a67218403f78737f2c4dc92d2fd96dc125d$
+// $hash=46a6432f66cce88d8597c3d070681b09a712dc54$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
@@ -47,99 +47,102 @@ extern "C" {
 #endif
 
 ///
-// Crash reporting is configured using an INI-style config file named
-// "crash_reporter.cfg". On Windows and Linux this file must be placed next to
-// the main application executable. On macOS this file must be placed in the
-// top-level app bundle Resources directory (e.g.
-// "<appname>.app/Contents/Resources"). File contents are as follows:
-//
-//  # Comments start with a hash character and must be on their own line.
-//
-//  [Config]
-//  ProductName=<Value of the "prod" crash key; defaults to "cef">
-//  ProductVersion=<Value of the "ver" crash key; defaults to the CEF version>
-//  AppName=<Windows only; App-specific folder name component for storing crash
-//           information; default to "CEF">
-//  ExternalHandler=<Windows only; Name of the external handler exe to use
-//                   instead of re-launching the main exe; default to empty>
-//  BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes
-//                                 should be forwarded to the system crash
-//                                 reporter; default to false>
-//  ServerURL=<crash server URL; default to empty>
-//  RateLimitEnabled=<True if uploads should be rate limited; default to true>
-//  MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled;
-//                    default to 5>
-//  MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value
-//                       will cause older reports to be deleted; default to 20>
-//  MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted;
-//                        default to 5>
-//
-//  [CrashKeys]
-//  my_key1=<small|medium|large>
-//  my_key2=<small|medium|large>
-//
-// Config section:
-//
-// If "ProductName" and/or "ProductVersion" are set then the specified values
-// will be included in the crash dump metadata. On macOS if these values are set
-// to NULL then they will be retrieved from the Info.plist file using the
-// "CFBundleName" and "CFBundleShortVersionString" keys respectively.
-//
-// If "AppName" is set on Windows then crash report information (metrics,
-// database and dumps) will be stored locally on disk under the
-// "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other
-// platforms the CefSettings.user_data_path value will be used.
-//
-// If "ExternalHandler" is set on Windows then the specified exe will be
-// launched as the crashpad-handler instead of re-launching the main process
-// exe. The value can be an absolute path or a path relative to the main exe
-// directory. On Linux the CefSettings.browser_subprocess_path value will be
-// used. On macOS the existing subprocess app bundle will be used.
-//
-// If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser
-// process crashes will be forwarded to the system crash reporter. This results
-// in the crash UI dialog being displayed to the user and crash reports being
-// logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports
-// from non-browser processes and Debug builds is always disabled.
-//
-// If "ServerURL" is set then crashes will be uploaded as a multi-part POST
-// request to the specified URL. Otherwise, reports will only be stored locally
-// on disk.
-//
-// If "RateLimitEnabled" is set to true (1) then crash report uploads will be
-// rate limited as follows:
-//  1. If "MaxUploadsPerDay" is set to a positive value then at most the
-//     specified number of crashes will be uploaded in each 24 hour period.
-//  2. If crash upload fails due to a network or server error then an
-//     incremental backoff delay up to a maximum of 24 hours will be applied for
-//     retries.
-//  3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the
-//     "MaxUploadsPerDay" value will be reduced to 1 until the client is
-//     restarted. This helps to avoid an upload flood when the network or
-//     server error is resolved.
-// Rate limiting is not supported on Linux.
-//
-// If "MaxDatabaseSizeInMb" is set to a positive value then crash report storage
-// on disk will be limited to that size in megabytes. For example, on Windows
-// each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20 equates to
-// about 34 crash reports stored on disk. Not supported on Linux.
-//
-// If "MaxDatabaseAgeInDays" is set to a positive value then crash reports older
-// than the specified age in days will be deleted. Not supported on Linux.
-//
-// CrashKeys section:
-//
-// A maximum of 26 crash keys of each size can be specified for use by the
-// application. Crash key values will be truncated based on the specified size
-// (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of
-// crash keys can be set from any thread or process using the
-// CefSetCrashKeyValue function. These key/value pairs will be sent to the crash
-// server along with the crash dump file.
+/// Crash reporting is configured using an INI-style config file named
+/// "crash_reporter.cfg". On Windows and Linux this file must be placed next to
+/// the main application executable. On macOS this file must be placed in the
+/// top-level app bundle Resources directory (e.g.
+/// "<appname>.app/Contents/Resources"). File contents are as follows:
+///
+/// <pre>
+///  # Comments start with a hash character and must be on their own line.
+///
+///  [Config]
+///  ProductName=<Value of the "prod" crash key; defaults to "cef">
+///  ProductVersion=<Value of the "ver" crash key; defaults to the CEF version>
+///  AppName=<Windows only; App-specific folder name component for storing crash
+///           information; default to "CEF">
+///  ExternalHandler=<Windows only; Name of the external handler exe to use
+///                   instead of re-launching the main exe; default to empty>
+///  BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes
+///                                 should be forwarded to the system crash
+///                                 reporter; default to false>
+///  ServerURL=<crash server URL; default to empty>
+///  RateLimitEnabled=<True if uploads should be rate limited; default to true>
+///  MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled;
+///                    default to 5>
+///  MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value
+///                       will cause older reports to be deleted; default to 20>
+///  MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted;
+///                        default to 5>
+///
+///  [CrashKeys]
+///  my_key1=<small|medium|large>
+///  my_key2=<small|medium|large>
+/// </pre>
+///
+/// <b>Config section:</b>
+///
+/// If "ProductName" and/or "ProductVersion" are set then the specified values
+/// will be included in the crash dump metadata. On macOS if these values are
+/// set to NULL then they will be retrieved from the Info.plist file using the
+/// "CFBundleName" and "CFBundleShortVersionString" keys respectively.
+///
+/// If "AppName" is set on Windows then crash report information (metrics,
+/// database and dumps) will be stored locally on disk under the
+/// "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other
+/// platforms the cef_settings_t.root_cache_path value will be used.
+///
+/// If "ExternalHandler" is set on Windows then the specified exe will be
+/// launched as the crashpad-handler instead of re-launching the main process
+/// exe. The value can be an absolute path or a path relative to the main exe
+/// directory. On Linux the cef_settings_t.browser_subprocess_path value will be
+/// used. On macOS the existing subprocess app bundle will be used.
+///
+/// If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser
+/// process crashes will be forwarded to the system crash reporter. This results
+/// in the crash UI dialog being displayed to the user and crash reports being
+/// logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports
+/// from non-browser processes and Debug builds is always disabled.
+///
+/// If "ServerURL" is set then crashes will be uploaded as a multi-part POST
+/// request to the specified URL. Otherwise, reports will only be stored locally
+/// on disk.
+///
+/// If "RateLimitEnabled" is set to true (1) then crash report uploads will be
+/// rate limited as follows:
+///  1. If "MaxUploadsPerDay" is set to a positive value then at most the
+///     specified number of crashes will be uploaded in each 24 hour period.
+///  2. If crash upload fails due to a network or server error then an
+///     incremental backoff delay up to a maximum of 24 hours will be applied
+///     for retries.
+///  3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the
+///     "MaxUploadsPerDay" value will be reduced to 1 until the client is
+///     restarted. This helps to avoid an upload flood when the network or
+///     server error is resolved.
+/// Rate limiting is not supported on Linux.
+///
+/// If "MaxDatabaseSizeInMb" is set to a positive value then crash report
+/// storage on disk will be limited to that size in megabytes. For example, on
+/// Windows each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20
+/// equates to about 34 crash reports stored on disk. Not supported on Linux.
+///
+/// If "MaxDatabaseAgeInDays" is set to a positive value then crash reports
+/// older than the specified age in days will be deleted. Not supported on
+/// Linux.
+///
+/// <b>CrashKeys section:</b>
+///
+/// A maximum of 26 crash keys of each size can be specified for use by the
+/// application. Crash key values will be truncated based on the specified size
+/// (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of
+/// crash keys can be set from any thread or process using the
+/// CefSetCrashKeyValue function. These key/value pairs will be sent to the
+/// crash server along with the crash dump file.
 ///
 CEF_EXPORT int cef_crash_reporting_enabled(void);
 
 ///
-// Sets or clears a specific key-value pair from the crash metadata.
+/// Sets or clears a specific key-value pair from the crash metadata.
 ///
 CEF_EXPORT void cef_set_crash_key_value(const cef_string_t* key,
                                         const cef_string_t* value);

include/capi/cef_devtools_message_observer_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=ec62239c2b24ff512b64ca758be825ff57fb3b6b$
+// $hash=dd94c50619e92bf5bed4fe61479813ee559f779d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_
@@ -49,35 +49,36 @@ extern "C" {
 struct _cef_browser_t;
 
 ///
-// Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The
-// functions of this structure will be called on the browser process UI thread.
+/// Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The
+/// functions of this structure will be called on the browser process UI thread.
 ///
 typedef struct _cef_dev_tools_message_observer_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method that will be called on receipt of a DevTools protocol message.
-  // |browser| is the originating browser instance. |message| is a UTF8-encoded
-  // JSON dictionary representing either a function result or an event.
-  // |message| is only valid for the scope of this callback and should be copied
-  // if necessary. Return true (1) if the message was handled or false (0) if
-  // the message should be further processed and passed to the
-  // OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate.
-  //
-  // Method result dictionaries include an "id" (int) value that identifies the
-  // orginating function call sent from cef_browser_host_t::SendDevToolsMessage,
-  // and optionally either a "result" (dictionary) or "error" (dictionary)
-  // value. The "error" dictionary will contain "code" (int) and "message"
-  // (string) values. Event dictionaries include a "function" (string) value and
-  // optionally a "params" (dictionary) value. See the DevTools protocol
-  // documentation at https://chromedevtools.github.io/devtools-protocol/ for
-  // details of supported function calls and the expected "result" or "params"
-  // dictionary contents. JSON dictionaries can be parsed using the CefParseJSON
-  // function if desired, however be aware of performance considerations when
-  // parsing large messages (some of which may exceed 1MB in size).
+  /// Method that will be called on receipt of a DevTools protocol message.
+  /// |browser| is the originating browser instance. |message| is a UTF8-encoded
+  /// JSON dictionary representing either a function result or an event.
+  /// |message| is only valid for the scope of this callback and should be
+  /// copied if necessary. Return true (1) if the message was handled or false
+  /// (0) if the message should be further processed and passed to the
+  /// OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate.
+  ///
+  /// Method result dictionaries include an "id" (int) value that identifies the
+  /// orginating function call sent from
+  /// cef_browser_host_t::SendDevToolsMessage, and optionally either a "result"
+  /// (dictionary) or "error" (dictionary) value. The "error" dictionary will
+  /// contain "code" (int) and "message" (string) values. Event dictionaries
+  /// include a "function" (string) value and optionally a "params" (dictionary)
+  /// value. See the DevTools protocol documentation at
+  /// https://chromedevtools.github.io/devtools-protocol/ for details of
+  /// supported function calls and the expected "result" or "params" dictionary
+  /// contents. JSON dictionaries can be parsed using the CefParseJSON function
+  /// if desired, however be aware of performance considerations when parsing
+  /// large messages (some of which may exceed 1MB in size).
   ///
   int(CEF_CALLBACK* on_dev_tools_message)(
       struct _cef_dev_tools_message_observer_t* self,
@@ -86,16 +87,16 @@ typedef struct _cef_dev_tools_message_observer_t {
       size_t message_size);
 
   ///
-  // Method that will be called after attempted execution of a DevTools protocol
-  // function. |browser| is the originating browser instance. |message_id| is
-  // the "id" value that identifies the originating function call message. If
-  // the function succeeded |success| will be true (1) and |result| will be the
-  // UTF8-encoded JSON "result" dictionary value (which may be NULL). If the
-  // function failed |success| will be false (0) and |result| will be the
-  // UTF8-encoded JSON "error" dictionary value. |result| is only valid for the
-  // scope of this callback and should be copied if necessary. See the
-  // OnDevToolsMessage documentation for additional details on |result|
-  // contents.
+  /// Method that will be called after attempted execution of a DevTools
+  /// protocol function. |browser| is the originating browser instance.
+  /// |message_id| is the "id" value that identifies the originating function
+  /// call message. If the function succeeded |success| will be true (1) and
+  /// |result| will be the UTF8-encoded JSON "result" dictionary value (which
+  /// may be NULL). If the function failed |success| will be false (0) and
+  /// |result| will be the UTF8-encoded JSON "error" dictionary value. |result|
+  /// is only valid for the scope of this callback and should be copied if
+  /// necessary. See the OnDevToolsMessage documentation for additional details
+  /// on |result| contents.
   ///
   void(CEF_CALLBACK* on_dev_tools_method_result)(
       struct _cef_dev_tools_message_observer_t* self,
@@ -106,12 +107,12 @@ typedef struct _cef_dev_tools_message_observer_t {
       size_t result_size);
 
   ///
-  // Method that will be called on receipt of a DevTools protocol event.
-  // |browser| is the originating browser instance. |function| is the "function"
-  // value. |params| is the UTF8-encoded JSON "params" dictionary value (which
-  // may be NULL). |params| is only valid for the scope of this callback and
-  // should be copied if necessary. See the OnDevToolsMessage documentation for
-  // additional details on |params| contents.
+  /// Method that will be called on receipt of a DevTools protocol event.
+  /// |browser| is the originating browser instance. |function| is the
+  /// "function" value. |params| is the UTF8-encoded JSON "params" dictionary
+  /// value (which may be NULL). |params| is only valid for the scope of this
+  /// callback and should be copied if necessary. See the OnDevToolsMessage
+  /// documentation for additional details on |params| contents.
   ///
   void(CEF_CALLBACK* on_dev_tools_event)(
       struct _cef_dev_tools_message_observer_t* self,
@@ -121,19 +122,19 @@ typedef struct _cef_dev_tools_message_observer_t {
       size_t params_size);
 
   ///
-  // Method that will be called when the DevTools agent has attached. |browser|
-  // is the originating browser instance. This will generally occur in response
-  // to the first message sent while the agent is detached.
+  /// Method that will be called when the DevTools agent has attached. |browser|
+  /// is the originating browser instance. This will generally occur in response
+  /// to the first message sent while the agent is detached.
   ///
   void(CEF_CALLBACK* on_dev_tools_agent_attached)(
       struct _cef_dev_tools_message_observer_t* self,
       struct _cef_browser_t* browser);
 
   ///
-  // Method that will be called when the DevTools agent has detached. |browser|
-  // is the originating browser instance. Any function results that were pending
-  // before the agent became detached will not be delivered, and any active
-  // event subscriptions will be canceled.
+  /// Method that will be called when the DevTools agent has detached. |browser|
+  /// is the originating browser instance. Any function results that were
+  /// pending before the agent became detached will not be delivered, and any
+  /// active event subscriptions will be canceled.
   ///
   void(CEF_CALLBACK* on_dev_tools_agent_detached)(
       struct _cef_dev_tools_message_observer_t* self,

include/capi/cef_dialog_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=0f56154217707d141912dc8a298279df8df04311$
+// $hash=bf7208a86ee17f63fd7163cef8c3a13373a1f1c8$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
@@ -48,55 +48,58 @@ extern "C" {
 #endif
 
 ///
-// Callback structure for asynchronous continuation of file dialog requests.
+/// Callback structure for asynchronous continuation of file dialog requests.
 ///
 typedef struct _cef_file_dialog_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Continue the file selection. |selected_accept_filter| should be the 0-based
-  // index of the value selected from the accept filters array passed to
-  // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
-  // or a list of values depending on the dialog mode. An NULL |file_paths|
-  // value is treated the same as calling cancel().
+  /// Continue the file selection. |file_paths| should be a single value or a
+  /// list of values depending on the dialog mode. An NULL |file_paths| value is
+  /// treated the same as calling cancel().
   ///
   void(CEF_CALLBACK* cont)(struct _cef_file_dialog_callback_t* self,
-                           int selected_accept_filter,
                            cef_string_list_t file_paths);
 
   ///
-  // Cancel the file selection.
+  /// Cancel the file selection.
   ///
   void(CEF_CALLBACK* cancel)(struct _cef_file_dialog_callback_t* self);
 } cef_file_dialog_callback_t;
 
 ///
-// Implement this structure to handle dialog events. The functions of this
-// structure will be called on the browser process UI thread.
+/// Implement this structure to handle dialog events. The functions of this
+/// structure will be called on the browser process UI thread.
 ///
 typedef struct _cef_dialog_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called to run a file chooser dialog. |mode| represents the type of dialog
-  // to display. |title| to the title to be used for the dialog and may be NULL
-  // to show the default title ("Open" or "Save" depending on the mode).
-  // |default_file_path| is the path with optional directory and/or file name
-  // component that should be initially selected in the dialog. |accept_filters|
-  // are used to restrict the selectable file types and may any combination of
-  // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
-  // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
-  // description and file extension delimited using "|" and ";" (e.g. "Image
-  // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
-  // the filter that should be selected by default. To display a custom dialog
-  // return true (1) and execute |callback| either inline or at a later time. To
-  // display the default dialog return false (0).
+  /// Called to run a file chooser dialog. |mode| represents the type of dialog
+  /// to display. |title| to the title to be used for the dialog and may be NULL
+  /// to show the default title ("Open" or "Save" depending on the mode).
+  /// |default_file_path| is the path with optional directory and/or file name
+  /// component that should be initially selected in the dialog.
+  /// |accept_filters| are used to restrict the selectable file types and may be
+  /// any combination of valid lower-cased MIME types (e.g. "text/*" or
+  /// "image/*") and individual file extensions (e.g. ".txt" or ".png").
+  /// |accept_extensions| provides the semicolon-delimited expansion of MIME
+  /// types to file extensions (if known, or NULL string otherwise).
+  /// |accept_descriptions| provides the descriptions for MIME types (if known,
+  /// or NULL string otherwise). For example, the "image/*" mime type might have
+  /// extensions ".png;.jpg;.bmp;..." and description "Image Files".
+  /// |accept_filters|, |accept_extensions| and |accept_descriptions| will all
+  /// be the same size. To display a custom dialog return true (1) and execute
+  /// |callback| either inline or at a later time. To display the default dialog
+  /// return false (0). If this function returns false (0) it may be called an
+  /// additional time for the same dialog (both before and after MIME type
+  /// expansion).
   ///
   int(CEF_CALLBACK* on_file_dialog)(
       struct _cef_dialog_handler_t* self,
@@ -105,7 +108,8 @@ typedef struct _cef_dialog_handler_t {
       const cef_string_t* title,
       const cef_string_t* default_file_path,
       cef_string_list_t accept_filters,
-      int selected_accept_filter,
+      cef_string_list_t accept_extensions,
+      cef_string_list_t accept_descriptions,
       struct _cef_file_dialog_callback_t* callback);
 } cef_dialog_handler_t;
 

include/capi/cef_display_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=142637539a094a03adc71d2f3f5b711ba64918b1$
+// $hash=b42d9e5a03f6ef5444e8037b8dc4de08ee6b0834$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@@ -49,17 +49,17 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to browser display state.
-// The functions of this structure will be called on the UI thread.
+/// Implement this structure to handle events related to browser display state.
+/// The functions of this structure will be called on the UI thread.
 ///
 typedef struct _cef_display_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called when a frame's address has changed.
+  /// Called when a frame's address has changed.
   ///
   void(CEF_CALLBACK* on_address_change)(struct _cef_display_handler_t* self,
                                         struct _cef_browser_t* browser,
@@ -67,25 +67,29 @@ typedef struct _cef_display_handler_t {
                                         const cef_string_t* url);
 
   ///
-  // Called when the page title changes.
+  /// Called when the page title changes.
   ///
   void(CEF_CALLBACK* on_title_change)(struct _cef_display_handler_t* self,
                                       struct _cef_browser_t* browser,
                                       const cef_string_t* title);
 
   ///
-  // Called when the page icon changes.
+  /// Called when the page icon changes.
   ///
   void(CEF_CALLBACK* on_favicon_urlchange)(struct _cef_display_handler_t* self,
                                            struct _cef_browser_t* browser,
                                            cef_string_list_t icon_urls);
 
   ///
-  // Called when web content in the page has toggled fullscreen mode. If
-  // |fullscreen| is true (1) the content will automatically be sized to fill
-  // the browser content area. If |fullscreen| is false (0) the content will
-  // automatically return to its original size and position. The client is
-  // responsible for resizing the browser if desired.
+  /// Called when web content in the page has toggled fullscreen mode. If
+  /// |fullscreen| is true (1) the content will automatically be sized to fill
+  /// the browser content area. If |fullscreen| is false (0) the content will
+  /// automatically return to its original size and position. With Alloy style
+  /// the client is responsible for triggering the fullscreen transition (for
+  /// example, by calling cef_window_t::SetFullscreen when using Views). With
+  /// Chrome style the fullscreen transition will be triggered automatically.
+  /// The cef_window_delegate_t::OnWindowFullscreenTransition function will be
+  /// called during the fullscreen transition for notification purposes.
   ///
   void(CEF_CALLBACK* on_fullscreen_mode_change)(
       struct _cef_display_handler_t* self,
@@ -93,28 +97,28 @@ typedef struct _cef_display_handler_t {
       int fullscreen);
 
   ///
-  // Called when the browser is about to display a tooltip. |text| contains the
-  // text that will be displayed in the tooltip. To handle the display of the
-  // tooltip yourself return true (1). Otherwise, you can optionally modify
-  // |text| and then return false (0) to allow the browser to display the
-  // tooltip. When window rendering is disabled the application is responsible
-  // for drawing tooltips and the return value is ignored.
+  /// Called when the browser is about to display a tooltip. |text| contains the
+  /// text that will be displayed in the tooltip. To handle the display of the
+  /// tooltip yourself return true (1). Otherwise, you can optionally modify
+  /// |text| and then return false (0) to allow the browser to display the
+  /// tooltip. When window rendering is disabled the application is responsible
+  /// for drawing tooltips and the return value is ignored.
   ///
   int(CEF_CALLBACK* on_tooltip)(struct _cef_display_handler_t* self,
                                 struct _cef_browser_t* browser,
                                 cef_string_t* text);
 
   ///
-  // Called when the browser receives a status message. |value| contains the
-  // text that will be displayed in the status message.
+  /// Called when the browser receives a status message. |value| contains the
+  /// text that will be displayed in the status message.
   ///
   void(CEF_CALLBACK* on_status_message)(struct _cef_display_handler_t* self,
                                         struct _cef_browser_t* browser,
                                         const cef_string_t* value);
 
   ///
-  // Called to display a console message. Return true (1) to stop the message
-  // from being output to the console.
+  /// Called to display a console message. Return true (1) to stop the message
+  /// from being output to the console.
   ///
   int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self,
                                         struct _cef_browser_t* browser,
@@ -124,18 +128,18 @@ typedef struct _cef_display_handler_t {
                                         int line);
 
   ///
-  // Called when auto-resize is enabled via
-  // cef_browser_host_t::SetAutoResizeEnabled and the contents have auto-
-  // resized. |new_size| will be the desired size in view coordinates. Return
-  // true (1) if the resize was handled or false (0) for default handling.
+  /// Called when auto-resize is enabled via
+  /// cef_browser_host_t::SetAutoResizeEnabled and the contents have auto-
+  /// resized. |new_size| will be the desired size in view coordinates. Return
+  /// true (1) if the resize was handled or false (0) for default handling.
   ///
   int(CEF_CALLBACK* on_auto_resize)(struct _cef_display_handler_t* self,
                                     struct _cef_browser_t* browser,
                                     const cef_size_t* new_size);
 
   ///
-  // Called when the overall page loading progress has changed. |progress|
-  // ranges from 0.0 to 1.0.
+  /// Called when the overall page loading progress has changed. |progress|
+  /// ranges from 0.0 to 1.0.
   ///
   void(CEF_CALLBACK* on_loading_progress_change)(
       struct _cef_display_handler_t* self,
@@ -143,17 +147,27 @@ typedef struct _cef_display_handler_t {
       double progress);
 
   ///
-  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
-  // |custom_cursor_info| will be populated with the custom cursor information.
-  // Return true (1) if the cursor change was handled or false (0) for default
-  // handling.
+  /// Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+  /// |custom_cursor_info| will be populated with the custom cursor information.
+  /// Return true (1) if the cursor change was handled or false (0) for default
+  /// handling.
   ///
   int(CEF_CALLBACK* on_cursor_change)(
       struct _cef_display_handler_t* self,
       struct _cef_browser_t* browser,
       cef_cursor_handle_t cursor,
       cef_cursor_type_t type,
-      const struct _cef_cursor_info_t* custom_cursor_info);
+      const cef_cursor_info_t* custom_cursor_info);
+
+  ///
+  /// Called when the browser's access to an audio and/or video source has
+  /// changed.
+  ///
+  void(CEF_CALLBACK* on_media_access_change)(
+      struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser,
+      int has_video_access,
+      int has_audio_access);
 } cef_display_handler_t;
 
 #ifdef __cplusplus

include/capi/cef_dom_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c6de3fb4d64a2b2ad06a4b9c5e9d7625d40b5bb6$
+// $hash=a4d2f79163205ed4367916546240a6aedc2165f9$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
@@ -50,120 +50,120 @@ struct _cef_domdocument_t;
 struct _cef_domnode_t;
 
 ///
-// Structure to implement for visiting the DOM. The functions of this structure
-// will be called on the render process main thread.
+/// Structure to implement for visiting the DOM. The functions of this structure
+/// will be called on the render process main thread.
 ///
 typedef struct _cef_domvisitor_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Method executed for visiting the DOM. The document object passed to this
-  // function represents a snapshot of the DOM at the time this function is
-  // executed. DOM objects are only valid for the scope of this function. Do not
-  // keep references to or attempt to access any DOM objects outside the scope
-  // of this function.
+  /// Method executed for visiting the DOM. The document object passed to this
+  /// function represents a snapshot of the DOM at the time this function is
+  /// executed. DOM objects are only valid for the scope of this function. Do
+  /// not keep references to or attempt to access any DOM objects outside the
+  /// scope of this function.
   ///
   void(CEF_CALLBACK* visit)(struct _cef_domvisitor_t* self,
                             struct _cef_domdocument_t* document);
 } cef_domvisitor_t;
 
 ///
-// Structure used to represent a DOM document. The functions of this structure
-// should only be called on the render process main thread thread.
+/// Structure used to represent a DOM document. The functions of this structure
+/// should only be called on the render process main thread thread.
 ///
 typedef struct _cef_domdocument_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns the document type.
+  /// Returns the document type.
   ///
   cef_dom_document_type_t(CEF_CALLBACK* get_type)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the root document node.
+  /// Returns the root document node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_document)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the BODY node of an HTML document.
+  /// Returns the BODY node of an HTML document.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_body)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the HEAD node of an HTML document.
+  /// Returns the HEAD node of an HTML document.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_head)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the title of an HTML document.
+  /// Returns the title of an HTML document.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_title)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the document element with the specified ID value.
+  /// Returns the document element with the specified ID value.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_element_by_id)(
       struct _cef_domdocument_t* self,
       const cef_string_t* id);
 
   ///
-  // Returns the node that currently has keyboard focus.
+  /// Returns the node that currently has keyboard focus.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_focused_node)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns true (1) if a portion of the document is selected.
+  /// Returns true (1) if a portion of the document is selected.
   ///
   int(CEF_CALLBACK* has_selection)(struct _cef_domdocument_t* self);
 
   ///
-  // Returns the selection offset within the start node.
+  /// Returns the selection offset within the start node.
   ///
   int(CEF_CALLBACK* get_selection_start_offset)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the selection offset within the end node.
+  /// Returns the selection offset within the end node.
   ///
   int(CEF_CALLBACK* get_selection_end_offset)(struct _cef_domdocument_t* self);
 
   ///
-  // Returns the contents of this selection as markup.
+  /// Returns the contents of this selection as markup.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_selection_as_markup)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the contents of this selection as text.
+  /// Returns the contents of this selection as text.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_selection_as_text)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns the base URL for the document.
+  /// Returns the base URL for the document.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_base_url)(
       struct _cef_domdocument_t* self);
 
   ///
-  // Returns a complete URL based on the document base URL and the specified
-  // partial URL.
+  /// Returns a complete URL based on the document base URL and the specified
+  /// partial URL.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_complete_url)(
@@ -172,141 +172,138 @@ typedef struct _cef_domdocument_t {
 } cef_domdocument_t;
 
 ///
-// Structure used to represent a DOM node. The functions of this structure
-// should only be called on the render process main thread.
+/// Structure used to represent a DOM node. The functions of this structure
+/// should only be called on the render process main thread.
 ///
 typedef struct _cef_domnode_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns the type for this node.
+  /// Returns the type for this node.
   ///
   cef_dom_node_type_t(CEF_CALLBACK* get_type)(struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this is a text node.
+  /// Returns true (1) if this is a text node.
   ///
   int(CEF_CALLBACK* is_text)(struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this is an element node.
+  /// Returns true (1) if this is an element node.
   ///
   int(CEF_CALLBACK* is_element)(struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this is an editable node.
+  /// Returns true (1) if this is an editable node.
   ///
   int(CEF_CALLBACK* is_editable)(struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this is a form control element node.
+  /// Returns true (1) if this is a form control element node.
   ///
   int(CEF_CALLBACK* is_form_control_element)(struct _cef_domnode_t* self);
 
   ///
-  // Returns the type of this form control element node.
+  /// Returns the type of this form control element node.
   ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_form_control_element_type)(
+  cef_dom_form_control_type_t(CEF_CALLBACK* get_form_control_element_type)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this object is pointing to the same handle as |that|
-  // object.
+  /// Returns true (1) if this object is pointing to the same handle as |that|
+  /// object.
   ///
   int(CEF_CALLBACK* is_same)(struct _cef_domnode_t* self,
                              struct _cef_domnode_t* that);
 
   ///
-  // Returns the name of this node.
+  /// Returns the name of this node.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_domnode_t* self);
 
   ///
-  // Returns the value of this node.
+  /// Returns the value of this node.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_value)(struct _cef_domnode_t* self);
 
   ///
-  // Set the value of this node. Returns true (1) on success.
+  /// Set the value of this node. Returns true (1) on success.
   ///
   int(CEF_CALLBACK* set_value)(struct _cef_domnode_t* self,
                                const cef_string_t* value);
 
   ///
-  // Returns the contents of this node as markup.
+  /// Returns the contents of this node as markup.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_as_markup)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the document associated with this node.
+  /// Returns the document associated with this node.
   ///
   struct _cef_domdocument_t*(CEF_CALLBACK* get_document)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the parent node.
+  /// Returns the parent node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self);
 
   ///
-  // Returns the previous sibling node.
+  /// Returns the previous sibling node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_previous_sibling)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the next sibling node.
+  /// Returns the next sibling node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_next_sibling)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this node has child nodes.
+  /// Returns true (1) if this node has child nodes.
   ///
   int(CEF_CALLBACK* has_children)(struct _cef_domnode_t* self);
 
   ///
-  // Return the first child node.
+  /// Return the first child node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_first_child)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the last child node.
+  /// Returns the last child node.
   ///
   struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)(
       struct _cef_domnode_t* self);
 
-  // The following functions are valid only for element nodes.
-
   ///
-  // Returns the tag name of this element.
+  /// Returns the tag name of this element.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_element_tag_name)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this element has attributes.
+  /// Returns true (1) if this element has attributes.
   ///
   int(CEF_CALLBACK* has_element_attributes)(struct _cef_domnode_t* self);
 
   ///
-  // Returns true (1) if this element has an attribute named |attrName|.
+  /// Returns true (1) if this element has an attribute named |attrName|.
   ///
   int(CEF_CALLBACK* has_element_attribute)(struct _cef_domnode_t* self,
                                            const cef_string_t* attrName);
 
   ///
-  // Returns the element attribute named |attrName|.
+  /// Returns the element attribute named |attrName|.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_element_attribute)(
@@ -314,28 +311,29 @@ typedef struct _cef_domnode_t {
       const cef_string_t* attrName);
 
   ///
-  // Returns a map of all element attributes.
+  /// Returns a map of all element attributes.
   ///
   void(CEF_CALLBACK* get_element_attributes)(struct _cef_domnode_t* self,
                                              cef_string_map_t attrMap);
 
   ///
-  // Set the value for the element attribute named |attrName|. Returns true (1)
-  // on success.
+  /// Set the value for the element attribute named |attrName|. Returns true (1)
+  /// on success.
   ///
   int(CEF_CALLBACK* set_element_attribute)(struct _cef_domnode_t* self,
                                            const cef_string_t* attrName,
                                            const cef_string_t* value);
 
   ///
-  // Returns the inner text of the element.
+  /// Returns the inner text of the element.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_element_inner_text)(
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the bounds of the element.
+  /// Returns the bounds of the element in device pixels. Use
+  /// "window.devicePixelRatio" to convert to/from CSS pixels.
   ///
   cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self);
 } cef_domnode_t;

include/capi/cef_download_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=ec13ec3e2819e4ac49792c3a1c57bc60b45fb95b$
+// $hash=7ecfb07a95315ff81937e9f68d419122fc88f1b7$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
@@ -49,19 +49,19 @@ extern "C" {
 #endif
 
 ///
-// Callback structure used to asynchronously continue a download.
+/// Callback structure used to asynchronously continue a download.
 ///
 typedef struct _cef_before_download_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Call to continue the download. Set |download_path| to the full file path
-  // for the download including the file name or leave blank to use the
-  // suggested name and the default temp directory. Set |show_dialog| to true
-  // (1) if you do wish to show the default "Save As" dialog.
+  /// Call to continue the download. Set |download_path| to the full file path
+  /// for the download including the file name or leave blank to use the
+  /// suggested name and the default temp directory. Set |show_dialog| to true
+  /// (1) if you do wish to show the default "Save As" dialog.
   ///
   void(CEF_CALLBACK* cont)(struct _cef_before_download_callback_t* self,
                            const cef_string_t* download_path,
@@ -69,48 +69,61 @@ typedef struct _cef_before_download_callback_t {
 } cef_before_download_callback_t;
 
 ///
-// Callback structure used to asynchronously cancel a download.
+/// Callback structure used to asynchronously cancel a download.
 ///
 typedef struct _cef_download_item_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Call to cancel the download.
+  /// Call to cancel the download.
   ///
   void(CEF_CALLBACK* cancel)(struct _cef_download_item_callback_t* self);
 
   ///
-  // Call to pause the download.
+  /// Call to pause the download.
   ///
   void(CEF_CALLBACK* pause)(struct _cef_download_item_callback_t* self);
 
   ///
-  // Call to resume the download.
+  /// Call to resume the download.
   ///
   void(CEF_CALLBACK* resume)(struct _cef_download_item_callback_t* self);
 } cef_download_item_callback_t;
 
 ///
-// Structure used to handle file downloads. The functions of this structure will
-// called on the browser process UI thread.
+/// Structure used to handle file downloads. The functions of this structure
+/// will called on the browser process UI thread.
 ///
 typedef struct _cef_download_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called before a download begins. |suggested_name| is the suggested name for
-  // the download file. By default the download will be canceled. Execute
-  // |callback| either asynchronously or in this function to continue the
-  // download if desired. Do not keep a reference to |download_item| outside of
-  // this function.
+  /// Called before a download begins in response to a user-initiated action
+  /// (e.g. alt + link click or link click that returns a `Content-Disposition:
+  /// attachment` response from the server). |url| is the target download URL
+  /// and |request_function| is the target function (GET, POST, etc). Return
+  /// true (1) to proceed with the download or false (0) to cancel the download.
   ///
-  void(CEF_CALLBACK* on_before_download)(
+  int(CEF_CALLBACK* can_download)(struct _cef_download_handler_t* self,
+                                  struct _cef_browser_t* browser,
+                                  const cef_string_t* url,
+                                  const cef_string_t* request_method);
+
+  ///
+  /// Called before a download begins. |suggested_name| is the suggested name
+  /// for the download file. Return true (1) and execute |callback| either
+  /// asynchronously or in this function to continue or cancel the download.
+  /// Return false (0) to proceed with default handling (cancel with Alloy
+  /// style, download shelf with Chrome style). Do not keep a reference to
+  /// |download_item| outside of this function.
+  ///
+  int(CEF_CALLBACK* on_before_download)(
       struct _cef_download_handler_t* self,
       struct _cef_browser_t* browser,
       struct _cef_download_item_t* download_item,
@@ -118,11 +131,11 @@ typedef struct _cef_download_handler_t {
       struct _cef_before_download_callback_t* callback);
 
   ///
-  // Called when a download's status or progress information has been updated.
-  // This may be called multiple times before and after on_before_download().
-  // Execute |callback| either asynchronously or in this function to cancel the
-  // download if desired. Do not keep a reference to |download_item| outside of
-  // this function.
+  /// Called when a download's status or progress information has been updated.
+  /// This may be called multiple times before and after on_before_download().
+  /// Execute |callback| either asynchronously or in this function to cancel the
+  /// download if desired. Do not keep a reference to |download_item| outside of
+  /// this function.
   ///
   void(CEF_CALLBACK* on_download_updated)(
       struct _cef_download_handler_t* self,

include/capi/cef_download_item_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=b9f0d91dd2fdb3625365ff8b332b08e1f0ea1187$
+// $hash=9af8ade3addfd112db41792c4e80682a8143e8c4$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
@@ -47,108 +47,120 @@ extern "C" {
 #endif
 
 ///
-// Structure used to represent a download item.
+/// Structure used to represent a download item.
 ///
 typedef struct _cef_download_item_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns true (1) if this object is valid. Do not call any other functions
-  // if this function returns false (0).
+  /// Returns true (1) if this object is valid. Do not call any other functions
+  /// if this function returns false (0).
   ///
   int(CEF_CALLBACK* is_valid)(struct _cef_download_item_t* self);
 
   ///
-  // Returns true (1) if the download is in progress.
+  /// Returns true (1) if the download is in progress.
   ///
   int(CEF_CALLBACK* is_in_progress)(struct _cef_download_item_t* self);
 
   ///
-  // Returns true (1) if the download is complete.
+  /// Returns true (1) if the download is complete.
   ///
   int(CEF_CALLBACK* is_complete)(struct _cef_download_item_t* self);
 
   ///
-  // Returns true (1) if the download has been canceled or interrupted.
+  /// Returns true (1) if the download has been canceled.
   ///
   int(CEF_CALLBACK* is_canceled)(struct _cef_download_item_t* self);
 
   ///
-  // Returns a simple speed estimate in bytes/s.
+  /// Returns true (1) if the download has been interrupted.
   ///
-  int64(CEF_CALLBACK* get_current_speed)(struct _cef_download_item_t* self);
+  int(CEF_CALLBACK* is_interrupted)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the rough percent complete or -1 if the receive total size is
-  // unknown.
+  /// Returns the most recent interrupt reason.
+  ///
+  cef_download_interrupt_reason_t(CEF_CALLBACK* get_interrupt_reason)(
+      struct _cef_download_item_t* self);
+
+  ///
+  /// Returns a simple speed estimate in bytes/s.
+  ///
+  int64_t(CEF_CALLBACK* get_current_speed)(struct _cef_download_item_t* self);
+
+  ///
+  /// Returns the rough percent complete or -1 if the receive total size is
+  /// unknown.
   ///
   int(CEF_CALLBACK* get_percent_complete)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the total number of bytes.
+  /// Returns the total number of bytes.
   ///
-  int64(CEF_CALLBACK* get_total_bytes)(struct _cef_download_item_t* self);
+  int64_t(CEF_CALLBACK* get_total_bytes)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the number of received bytes.
+  /// Returns the number of received bytes.
   ///
-  int64(CEF_CALLBACK* get_received_bytes)(struct _cef_download_item_t* self);
+  int64_t(CEF_CALLBACK* get_received_bytes)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the time that the download started.
+  /// Returns the time that the download started.
   ///
-  cef_time_t(CEF_CALLBACK* get_start_time)(struct _cef_download_item_t* self);
+  cef_basetime_t(CEF_CALLBACK* get_start_time)(
+      struct _cef_download_item_t* self);
 
   ///
-  // Returns the time that the download ended.
+  /// Returns the time that the download ended.
   ///
-  cef_time_t(CEF_CALLBACK* get_end_time)(struct _cef_download_item_t* self);
+  cef_basetime_t(CEF_CALLBACK* get_end_time)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the full path to the downloaded or downloading file.
+  /// Returns the full path to the downloaded or downloading file.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_full_path)(
       struct _cef_download_item_t* self);
 
   ///
-  // Returns the unique identifier for this download.
+  /// Returns the unique identifier for this download.
   ///
-  uint32(CEF_CALLBACK* get_id)(struct _cef_download_item_t* self);
+  uint32_t(CEF_CALLBACK* get_id)(struct _cef_download_item_t* self);
 
   ///
-  // Returns the URL.
+  /// Returns the URL.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_url)(
       struct _cef_download_item_t* self);
 
   ///
-  // Returns the original URL before any redirections.
+  /// Returns the original URL before any redirections.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_original_url)(
       struct _cef_download_item_t* self);
 
   ///
-  // Returns the suggested file name.
+  /// Returns the suggested file name.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_suggested_file_name)(
       struct _cef_download_item_t* self);
 
   ///
-  // Returns the content disposition.
+  /// Returns the content disposition.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_content_disposition)(
       struct _cef_download_item_t* self);
 
   ///
-  // Returns the mime type.
+  /// Returns the mime type.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_mime_type)(

include/capi/cef_drag_data_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=221973f3d5728478eeb0f8f5f55ca5e68b3afd8a$
+// $hash=a096775255ddc4d7616095e48e7370bd87bf4bb5$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
@@ -49,175 +49,187 @@ extern "C" {
 #endif
 
 ///
-// Structure used to represent drag data. The functions of this structure may be
-// called on any thread.
+/// Structure used to represent drag data. The functions of this structure may
+/// be called on any thread.
 ///
 typedef struct _cef_drag_data_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns a copy of the current object.
+  /// Returns a copy of the current object.
   ///
   struct _cef_drag_data_t*(CEF_CALLBACK* clone)(struct _cef_drag_data_t* self);
 
   ///
-  // Returns true (1) if this object is read-only.
+  /// Returns true (1) if this object is read-only.
   ///
   int(CEF_CALLBACK* is_read_only)(struct _cef_drag_data_t* self);
 
   ///
-  // Returns true (1) if the drag data is a link.
+  /// Returns true (1) if the drag data is a link.
   ///
   int(CEF_CALLBACK* is_link)(struct _cef_drag_data_t* self);
 
   ///
-  // Returns true (1) if the drag data is a text or html fragment.
+  /// Returns true (1) if the drag data is a text or html fragment.
   ///
   int(CEF_CALLBACK* is_fragment)(struct _cef_drag_data_t* self);
 
   ///
-  // Returns true (1) if the drag data is a file.
+  /// Returns true (1) if the drag data is a file.
   ///
   int(CEF_CALLBACK* is_file)(struct _cef_drag_data_t* self);
 
   ///
-  // Return the link URL that is being dragged.
+  /// Return the link URL that is being dragged.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_link_url)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the title associated with the link being dragged.
+  /// Return the title associated with the link being dragged.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_link_title)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the metadata, if any, associated with the link being dragged.
+  /// Return the metadata, if any, associated with the link being dragged.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_link_metadata)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the plain text fragment that is being dragged.
+  /// Return the plain text fragment that is being dragged.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_fragment_text)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the text/html fragment that is being dragged.
+  /// Return the text/html fragment that is being dragged.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_fragment_html)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the base URL that the fragment came from. This value is used for
-  // resolving relative URLs and may be NULL.
+  /// Return the base URL that the fragment came from. This value is used for
+  /// resolving relative URLs and may be NULL.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_fragment_base_url)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Return the name of the file being dragged out of the browser window.
+  /// Return the name of the file being dragged out of the browser window.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_file_name)(
       struct _cef_drag_data_t* self);
 
   ///
-  // Write the contents of the file being dragged out of the web view into
-  // |writer|. Returns the number of bytes sent to |writer|. If |writer| is NULL
-  // this function will return the size of the file contents in bytes. Call
-  // get_file_name() to get a suggested name for the file.
+  /// Write the contents of the file being dragged out of the web view into
+  /// |writer|. Returns the number of bytes sent to |writer|. If |writer| is
+  /// NULL this function will return the size of the file contents in bytes.
+  /// Call get_file_name() to get a suggested name for the file.
   ///
   size_t(CEF_CALLBACK* get_file_contents)(struct _cef_drag_data_t* self,
                                           struct _cef_stream_writer_t* writer);
 
   ///
-  // Retrieve the list of file names that are being dragged into the browser
-  // window.
+  /// Retrieve the list of file names that are being dragged into the browser
+  /// window.
   ///
   int(CEF_CALLBACK* get_file_names)(struct _cef_drag_data_t* self,
                                     cef_string_list_t names);
 
   ///
-  // Set the link URL that is being dragged.
+  /// Retrieve the list of file paths that are being dragged into the browser
+  /// window.
+  ///
+  int(CEF_CALLBACK* get_file_paths)(struct _cef_drag_data_t* self,
+                                    cef_string_list_t paths);
+
+  ///
+  /// Set the link URL that is being dragged.
   ///
   void(CEF_CALLBACK* set_link_url)(struct _cef_drag_data_t* self,
                                    const cef_string_t* url);
 
   ///
-  // Set the title associated with the link being dragged.
+  /// Set the title associated with the link being dragged.
   ///
   void(CEF_CALLBACK* set_link_title)(struct _cef_drag_data_t* self,
                                      const cef_string_t* title);
 
   ///
-  // Set the metadata associated with the link being dragged.
+  /// Set the metadata associated with the link being dragged.
   ///
   void(CEF_CALLBACK* set_link_metadata)(struct _cef_drag_data_t* self,
                                         const cef_string_t* data);
 
   ///
-  // Set the plain text fragment that is being dragged.
+  /// Set the plain text fragment that is being dragged.
   ///
   void(CEF_CALLBACK* set_fragment_text)(struct _cef_drag_data_t* self,
                                         const cef_string_t* text);
 
   ///
-  // Set the text/html fragment that is being dragged.
+  /// Set the text/html fragment that is being dragged.
   ///
   void(CEF_CALLBACK* set_fragment_html)(struct _cef_drag_data_t* self,
                                         const cef_string_t* html);
 
   ///
-  // Set the base URL that the fragment came from.
+  /// Set the base URL that the fragment came from.
   ///
   void(CEF_CALLBACK* set_fragment_base_url)(struct _cef_drag_data_t* self,
                                             const cef_string_t* base_url);
 
   ///
-  // Reset the file contents. You should do this before calling
-  // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
-  // to drag in this kind of data.
+  /// Reset the file contents. You should do this before calling
+  /// cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
+  /// to drag in this kind of data.
   ///
   void(CEF_CALLBACK* reset_file_contents)(struct _cef_drag_data_t* self);
 
   ///
-  // Add a file that is being dragged into the webview.
+  /// Add a file that is being dragged into the webview.
   ///
   void(CEF_CALLBACK* add_file)(struct _cef_drag_data_t* self,
                                const cef_string_t* path,
                                const cef_string_t* display_name);
 
   ///
-  // Get the image representation of drag data. May return NULL if no image
-  // representation is available.
+  /// Clear list of filenames.
+  ///
+  void(CEF_CALLBACK* clear_filenames)(struct _cef_drag_data_t* self);
+
+  ///
+  /// Get the image representation of drag data. May return NULL if no image
+  /// representation is available.
   ///
   struct _cef_image_t*(CEF_CALLBACK* get_image)(struct _cef_drag_data_t* self);
 
   ///
-  // Get the image hotspot (drag start location relative to image dimensions).
+  /// Get the image hotspot (drag start location relative to image dimensions).
   ///
   cef_point_t(CEF_CALLBACK* get_image_hotspot)(struct _cef_drag_data_t* self);
 
   ///
-  // Returns true (1) if an image representation of drag data is available.
+  /// Returns true (1) if an image representation of drag data is available.
   ///
   int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self);
 } cef_drag_data_t;
 
 ///
-// Create a new cef_drag_data_t object.
+/// Create a new cef_drag_data_t object.
 ///
 CEF_EXPORT cef_drag_data_t* cef_drag_data_create(void);
 

include/capi/cef_drag_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5b2051c42c1d4c41b85ca823d34b26bfa5de6777$
+// $hash=0723a2a59d46e465ac94f198351dc871f0b35b96$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
@@ -50,20 +50,20 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to dragging. The functions
-// of this structure will be called on the UI thread.
+/// Implement this structure to handle events related to dragging. The functions
+/// of this structure will be called on the UI thread.
 ///
 typedef struct _cef_drag_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called when an external drag event enters the browser window. |dragData|
-  // contains the drag event data and |mask| represents the type of drag
-  // operation. Return false (0) for default drag handling behavior or true (1)
-  // to cancel the drag event.
+  /// Called when an external drag event enters the browser window. |dragData|
+  /// contains the drag event data and |mask| represents the type of drag
+  /// operation. Return false (0) for default drag handling behavior or true (1)
+  /// to cancel the drag event.
   ///
   int(CEF_CALLBACK* on_drag_enter)(struct _cef_drag_handler_t* self,
                                    struct _cef_browser_t* browser,
@@ -71,11 +71,11 @@ typedef struct _cef_drag_handler_t {
                                    cef_drag_operations_mask_t mask);
 
   ///
-  // Called whenever draggable regions for the browser window change. These can
-  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
-  // draggable regions are never defined in a document this function will also
-  // never be called. If the last draggable region is removed from a document
-  // this function will be called with an NULL vector.
+  /// Called whenever draggable regions for the browser window change. These can
+  /// be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+  /// draggable regions are never defined in a document this function will also
+  /// never be called. If the last draggable region is removed from a document
+  /// this function will be called with an NULL vector.
   ///
   void(CEF_CALLBACK* on_draggable_regions_changed)(
       struct _cef_drag_handler_t* self,

include/capi/cef_extension_capi.h

@@ -1,130 +0,0 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=fcfe34c1517ebdb3f00c1f737b91361e771b820d$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_extension_handler_t;
-struct _cef_request_context_t;
-
-///
-// Object representing an extension. Methods may be called on any thread unless
-// otherwise indicated.
-///
-typedef struct _cef_extension_t {
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Returns the unique extension identifier. This is calculated based on the
-  // extension public key, if available, or on the extension path. See
-  // https://developer.chrome.com/extensions/manifest/key for details.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_identifier)(
-      struct _cef_extension_t* self);
-
-  ///
-  // Returns the absolute path to the extension directory on disk. This value
-  // will be prefixed with PK_DIR_RESOURCES if a relative path was passed to
-  // cef_request_context_t::LoadExtension.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_path)(struct _cef_extension_t* self);
-
-  ///
-  // Returns the extension manifest contents as a cef_dictionary_value_t object.
-  // See https://developer.chrome.com/extensions/manifest for details.
-  ///
-  struct _cef_dictionary_value_t*(CEF_CALLBACK* get_manifest)(
-      struct _cef_extension_t* self);
-
-  ///
-  // Returns true (1) if this object is the same extension as |that| object.
-  // Extensions are considered the same if identifier, path and loader context
-  // match.
-  ///
-  int(CEF_CALLBACK* is_same)(struct _cef_extension_t* self,
-                             struct _cef_extension_t* that);
-
-  ///
-  // Returns the handler for this extension. Will return NULL for internal
-  // extensions or if no handler was passed to
-  // cef_request_context_t::LoadExtension.
-  ///
-  struct _cef_extension_handler_t*(CEF_CALLBACK* get_handler)(
-      struct _cef_extension_t* self);
-
-  ///
-  // Returns the request context that loaded this extension. Will return NULL
-  // for internal extensions or if the extension has been unloaded. See the
-  // cef_request_context_t::LoadExtension documentation for more information
-  // about loader contexts. Must be called on the browser process UI thread.
-  ///
-  struct _cef_request_context_t*(CEF_CALLBACK* get_loader_context)(
-      struct _cef_extension_t* self);
-
-  ///
-  // Returns true (1) if this extension is currently loaded. Must be called on
-  // the browser process UI thread.
-  ///
-  int(CEF_CALLBACK* is_loaded)(struct _cef_extension_t* self);
-
-  ///
-  // Unload this extension if it is not an internal extension and is currently
-  // loaded. Will result in a call to
-  // cef_extension_handler_t::OnExtensionUnloaded on success.
-  ///
-  void(CEF_CALLBACK* unload)(struct _cef_extension_t* self);
-} cef_extension_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_

include/capi/cef_extension_handler_capi.h

@@ -1,210 +0,0 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=768e2436e54cceb2675ddd03ebdc61b5c0785bdc$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_extension_capi.h"
-#include "include/capi/cef_stream_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_client_t;
-
-///
-// Callback structure used for asynchronous continuation of
-// cef_extension_handler_t::GetExtensionResource.
-///
-typedef struct _cef_get_extension_resource_callback_t {
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Continue the request. Read the resource contents from |stream|.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_get_extension_resource_callback_t* self,
-                           struct _cef_stream_reader_t* stream);
-
-  ///
-  // Cancel the request.
-  ///
-  void(CEF_CALLBACK* cancel)(
-      struct _cef_get_extension_resource_callback_t* self);
-} cef_get_extension_resource_callback_t;
-
-///
-// Implement this structure to handle events related to browser extensions. The
-// functions of this structure will be called on the UI thread. See
-// cef_request_context_t::LoadExtension for information about extension loading.
-///
-typedef struct _cef_extension_handler_t {
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Called if the cef_request_context_t::LoadExtension request fails. |result|
-  // will be the error code.
-  ///
-  void(CEF_CALLBACK* on_extension_load_failed)(
-      struct _cef_extension_handler_t* self,
-      cef_errorcode_t result);
-
-  ///
-  // Called if the cef_request_context_t::LoadExtension request succeeds.
-  // |extension| is the loaded extension.
-  ///
-  void(CEF_CALLBACK* on_extension_loaded)(struct _cef_extension_handler_t* self,
-                                          struct _cef_extension_t* extension);
-
-  ///
-  // Called after the cef_extension_t::Unload request has completed.
-  ///
-  void(CEF_CALLBACK* on_extension_unloaded)(
-      struct _cef_extension_handler_t* self,
-      struct _cef_extension_t* extension);
-
-  ///
-  // Called when an extension needs a browser to host a background script
-  // specified via the "background" manifest key. The browser will have no
-  // visible window and cannot be displayed. |extension| is the extension that
-  // is loading the background script. |url| is an internally generated
-  // reference to an HTML page that will be used to load the background script
-  // via a <script> src attribute. To allow creation of the browser optionally
-  // modify |client| and |settings| and return false (0). To cancel creation of
-  // the browser (and consequently cancel load of the background script) return
-  // true (1). Successful creation will be indicated by a call to
-  // cef_life_span_handler_t::OnAfterCreated, and
-  // cef_browser_host_t::IsBackgroundHost will return true (1) for the resulting
-  // browser. See https://developer.chrome.com/extensions/event_pages for more
-  // information about extension background script usage.
-  ///
-  int(CEF_CALLBACK* on_before_background_browser)(
-      struct _cef_extension_handler_t* self,
-      struct _cef_extension_t* extension,
-      const cef_string_t* url,
-      struct _cef_client_t** client,
-      struct _cef_browser_settings_t* settings);
-
-  ///
-  // Called when an extension API (e.g. chrome.tabs.create) requests creation of
-  // a new browser. |extension| and |browser| are the source of the API call.
-  // |active_browser| may optionally be specified via the windowId property or
-  // returned via the get_active_browser() callback and provides the default
-  // |client| and |settings| values for the new browser. |index| is the position
-  // value optionally specified via the index property. |url| is the URL that
-  // will be loaded in the browser. |active| is true (1) if the new browser
-  // should be active when opened.  To allow creation of the browser optionally
-  // modify |windowInfo|, |client| and |settings| and return false (0). To
-  // cancel creation of the browser return true (1). Successful creation will be
-  // indicated by a call to cef_life_span_handler_t::OnAfterCreated. Any
-  // modifications to |windowInfo| will be ignored if |active_browser| is
-  // wrapped in a cef_browser_view_t.
-  ///
-  int(CEF_CALLBACK* on_before_browser)(
-      struct _cef_extension_handler_t* self,
-      struct _cef_extension_t* extension,
-      struct _cef_browser_t* browser,
-      struct _cef_browser_t* active_browser,
-      int index,
-      const cef_string_t* url,
-      int active,
-      struct _cef_window_info_t* windowInfo,
-      struct _cef_client_t** client,
-      struct _cef_browser_settings_t* settings);
-
-  ///
-  // Called when no tabId is specified to an extension API call that accepts a
-  // tabId parameter (e.g. chrome.tabs.*). |extension| and |browser| are the
-  // source of the API call. Return the browser that will be acted on by the API
-  // call or return NULL to act on |browser|. The returned browser must share
-  // the same cef_request_context_t as |browser|. Incognito browsers should not
-  // be considered unless the source extension has incognito access enabled, in
-  // which case |include_incognito| will be true (1).
-  ///
-  struct _cef_browser_t*(CEF_CALLBACK* get_active_browser)(
-      struct _cef_extension_handler_t* self,
-      struct _cef_extension_t* extension,
-      struct _cef_browser_t* browser,
-      int include_incognito);
-
-  ///
-  // Called when the tabId associated with |target_browser| is specified to an
-  // extension API call that accepts a tabId parameter (e.g. chrome.tabs.*).
-  // |extension| and |browser| are the source of the API call. Return true (1)
-  // to allow access of false (0) to deny access. Access to incognito browsers
-  // should not be allowed unless the source extension has incognito access
-  // enabled, in which case |include_incognito| will be true (1).
-  ///
-  int(CEF_CALLBACK* can_access_browser)(struct _cef_extension_handler_t* self,
-                                        struct _cef_extension_t* extension,
-                                        struct _cef_browser_t* browser,
-                                        int include_incognito,
-                                        struct _cef_browser_t* target_browser);
-
-  ///
-  // Called to retrieve an extension resource that would normally be loaded from
-  // disk (e.g. if a file parameter is specified to chrome.tabs.executeScript).
-  // |extension| and |browser| are the source of the resource request. |file| is
-  // the requested relative file path. To handle the resource request return
-  // true (1) and execute |callback| either synchronously or asynchronously. For
-  // the default behavior which reads the resource from the extension directory
-  // on disk return false (0). Localization substitutions will not be applied to
-  // resources handled via this function.
-  ///
-  int(CEF_CALLBACK* get_extension_resource)(
-      struct _cef_extension_handler_t* self,
-      struct _cef_extension_t* extension,
-      struct _cef_browser_t* browser,
-      const cef_string_t* file,
-      struct _cef_get_extension_resource_callback_t* callback);
-} cef_extension_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_

include/capi/cef_file_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=e76fa23e9682bf0865319d93e4009752ac8f854f$
+// $hash=e10581d1f6aeb104646ae106aaa5fb36016643dd$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
@@ -47,40 +47,40 @@ extern "C" {
 #endif
 
 ///
-// Creates a directory and all parent directories if they don't already exist.
-// Returns true (1) on successful creation or if the directory already exists.
-// The directory is only readable by the current user. Calling this function on
-// the browser process UI or IO threads is not allowed.
+/// Creates a directory and all parent directories if they don't already exist.
+/// Returns true (1) on successful creation or if the directory already exists.
+/// The directory is only readable by the current user. Calling this function on
+/// the browser process UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_create_directory(const cef_string_t* full_path);
 
 ///
-// Get the temporary directory provided by the system.
-//
-// WARNING: In general, you should use the temp directory variants below instead
-// of this function. Those variants will ensure that the proper permissions are
-// set so that other users on the system can't edit them while they're open
-// (which could lead to security issues).
+/// Get the temporary directory provided by the system.
+///
+/// WARNING: In general, you should use the temp directory variants below
+/// instead of this function. Those variants will ensure that the proper
+/// permissions are set so that other users on the system can't edit them while
+/// they're open (which could lead to security issues).
 ///
 CEF_EXPORT int cef_get_temp_directory(cef_string_t* temp_dir);
 
 ///
-// Creates a new directory. On Windows if |prefix| is provided the new directory
-// name is in the format of "prefixyyyy". Returns true (1) on success and sets
-// |new_temp_path| to the full path of the directory that was created. The
-// directory is only readable by the current user. Calling this function on the
-// browser process UI or IO threads is not allowed.
+/// Creates a new directory. On Windows if |prefix| is provided the new
+/// directory name is in the format of "prefixyyyy". Returns true (1) on success
+/// and sets |new_temp_path| to the full path of the directory that was created.
+/// The directory is only readable by the current user. Calling this function on
+/// the browser process UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_create_new_temp_directory(const cef_string_t* prefix,
                                              cef_string_t* new_temp_path);
 
 ///
-// Creates a directory within another directory. Extra characters will be
-// appended to |prefix| to ensure that the new directory does not have the same
-// name as an existing directory. Returns true (1) on success and sets |new_dir|
-// to the full path of the directory that was created. The directory is only
-// readable by the current user. Calling this function on the browser process UI
-// or IO threads is not allowed.
+/// Creates a directory within another directory. Extra characters will be
+/// appended to |prefix| to ensure that the new directory does not have the same
+/// name as an existing directory. Returns true (1) on success and sets
+/// |new_dir| to the full path of the directory that was created. The directory
+/// is only readable by the current user. Calling this function on the browser
+/// process UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_create_temp_directory_in_directory(
     const cef_string_t* base_dir,
@@ -88,39 +88,40 @@ CEF_EXPORT int cef_create_temp_directory_in_directory(
     cef_string_t* new_dir);
 
 ///
-// Returns true (1) if the given path exists and is a directory. Calling this
-// function on the browser process UI or IO threads is not allowed.
+/// Returns true (1) if the given path exists and is a directory. Calling this
+/// function on the browser process UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_directory_exists(const cef_string_t* path);
 
 ///
-// Deletes the given path whether it's a file or a directory. If |path| is a
-// directory all contents will be deleted.  If |recursive| is true (1) any sub-
-// directories and their contents will also be deleted (equivalent to executing
-// "rm -rf", so use with caution). On POSIX environments if |path| is a symbolic
-// link then only the symlink will be deleted. Returns true (1) on successful
-// deletion or if |path| does not exist. Calling this function on the browser
-// process UI or IO threads is not allowed.
+/// Deletes the given path whether it's a file or a directory. If |path| is a
+/// directory all contents will be deleted.  If |recursive| is true (1) any sub-
+/// directories and their contents will also be deleted (equivalent to executing
+/// "rm -rf", so use with caution). On POSIX environments if |path| is a
+/// symbolic link then only the symlink will be deleted. Returns true (1) on
+/// successful deletion or if |path| does not exist. Calling this function on
+/// the browser process UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_delete_file(const cef_string_t* path, int recursive);
 
 ///
-// Writes the contents of |src_dir| into a zip archive at |dest_file|. If
-// |include_hidden_files| is true (1) files starting with "." will be included.
-// Returns true (1) on success.  Calling this function on the browser process UI
-// or IO threads is not allowed.
+/// Writes the contents of |src_dir| into a zip archive at |dest_file|. If
+/// |include_hidden_files| is true (1) files starting with "." will be included.
+/// Returns true (1) on success.  Calling this function on the browser process
+/// UI or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_zip_directory(const cef_string_t* src_dir,
                                  const cef_string_t* dest_file,
                                  int include_hidden_files);
 
 ///
-// Loads the existing "Certificate Revocation Lists" file that is managed by
-// Google Chrome. This file can generally be found in Chrome's User Data
-// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on
-// Windows) and is updated periodically by Chrome's component updater service.
-// Must be called in the browser process after the context has been initialized.
-// See https://dev.chromium.org/Home/chromium-security/crlsets for background.
+/// Loads the existing "Certificate Revocation Lists" file that is managed by
+/// Google Chrome. This file can generally be found in Chrome's User Data
+/// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on
+/// Windows) and is updated periodically by Chrome's component updater service.
+/// Must be called in the browser process after the context has been
+/// initialized. See https://dev.chromium.org/Home/chromium-security/crlsets for
+/// background.
 ///
 CEF_EXPORT void cef_load_crlsets_file(const cef_string_t* path);
 

include/capi/cef_find_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=f2e80b8637b07f19adea666e554269de4627e399$
+// $hash=da0a9242b309fbd70d19949fb1c5b4ec4475ef94$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
@@ -48,23 +48,23 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to find results. The
-// functions of this structure will be called on the UI thread.
+/// Implement this structure to handle events related to find results. The
+/// functions of this structure will be called on the UI thread.
 ///
 typedef struct _cef_find_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called to report find results returned by cef_browser_host_t::find().
-  // |identifer| is a unique incremental identifier for the currently active
-  // search, |count| is the number of matches currently identified,
-  // |selectionRect| is the location of where the match was found (in window
-  // coordinates), |activeMatchOrdinal| is the current position in the search
-  // results, and |finalUpdate| is true (1) if this is the last find
-  // notification.
+  /// Called to report find results returned by cef_browser_host_t::find().
+  /// |identifer| is a unique incremental identifier for the currently active
+  /// search, |count| is the number of matches currently identified,
+  /// |selectionRect| is the location of where the match was found (in window
+  /// coordinates), |activeMatchOrdinal| is the current position in the search
+  /// results, and |finalUpdate| is true (1) if this is the last find
+  /// notification.
   ///
   void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
                                      struct _cef_browser_t* browser,

include/capi/cef_focus_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=a136a2679c8af339b21a89e8ae3090a9dbb8daa7$
+// $hash=6eefc2c650908461fb7536dd3314c77a3f89dceb$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
@@ -50,36 +50,37 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to focus. The functions of
-// this structure will be called on the UI thread.
+/// Implement this structure to handle events related to focus. The functions of
+/// this structure will be called on the UI thread.
 ///
 typedef struct _cef_focus_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called when the browser component is about to loose focus. For instance, if
-  // focus was on the last HTML element and the user pressed the TAB key. |next|
-  // will be true (1) if the browser is giving focus to the next component and
-  // false (0) if the browser is giving focus to the previous component.
+  /// Called when the browser component is about to loose focus. For instance,
+  /// if focus was on the last HTML element and the user pressed the TAB key.
+  /// |next| will be true (1) if the browser is giving focus to the next
+  /// component and false (0) if the browser is giving focus to the previous
+  /// component.
   ///
   void(CEF_CALLBACK* on_take_focus)(struct _cef_focus_handler_t* self,
                                     struct _cef_browser_t* browser,
                                     int next);
 
   ///
-  // Called when the browser component is requesting focus. |source| indicates
-  // where the focus request is originating from. Return false (0) to allow the
-  // focus to be set or true (1) to cancel setting the focus.
+  /// Called when the browser component is requesting focus. |source| indicates
+  /// where the focus request is originating from. Return false (0) to allow the
+  /// focus to be set or true (1) to cancel setting the focus.
   ///
   int(CEF_CALLBACK* on_set_focus)(struct _cef_focus_handler_t* self,
                                   struct _cef_browser_t* browser,
                                   cef_focus_source_t source);
 
   ///
-  // Called when the browser component has received focus.
+  /// Called when the browser component has received focus.
   ///
   void(CEF_CALLBACK* on_got_focus)(struct _cef_focus_handler_t* self,
                                    struct _cef_browser_t* browser);

include/capi/cef_frame_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=8527ceea6b8778d6fabc1b4ef82e4faa06ba777a$
+// $hash=8f347a95168778ec0e686cdef93be3bc517e2f68$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
@@ -57,100 +57,100 @@ struct _cef_urlrequest_t;
 struct _cef_v8context_t;
 
 ///
-// Structure used to represent a frame in the browser window. When used in the
-// browser process the functions of this structure may be called on any thread
-// unless otherwise indicated in the comments. When used in the render process
-// the functions of this structure may only be called on the main thread.
+/// Structure used to represent a frame in the browser window. When used in the
+/// browser process the functions of this structure may be called on any thread
+/// unless otherwise indicated in the comments. When used in the render process
+/// the functions of this structure may only be called on the main thread.
 ///
 typedef struct _cef_frame_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // True if this object is currently attached to a valid frame.
+  /// True if this object is currently attached to a valid frame.
   ///
   int(CEF_CALLBACK* is_valid)(struct _cef_frame_t* self);
 
   ///
-  // Execute undo in this frame.
+  /// Execute undo in this frame.
   ///
   void(CEF_CALLBACK* undo)(struct _cef_frame_t* self);
 
   ///
-  // Execute redo in this frame.
+  /// Execute redo in this frame.
   ///
   void(CEF_CALLBACK* redo)(struct _cef_frame_t* self);
 
   ///
-  // Execute cut in this frame.
+  /// Execute cut in this frame.
   ///
   void(CEF_CALLBACK* cut)(struct _cef_frame_t* self);
 
   ///
-  // Execute copy in this frame.
+  /// Execute copy in this frame.
   ///
   void(CEF_CALLBACK* copy)(struct _cef_frame_t* self);
 
   ///
-  // Execute paste in this frame.
+  /// Execute paste in this frame.
   ///
   void(CEF_CALLBACK* paste)(struct _cef_frame_t* self);
 
   ///
-  // Execute delete in this frame.
+  /// Execute delete in this frame.
   ///
   void(CEF_CALLBACK* del)(struct _cef_frame_t* self);
 
   ///
-  // Execute select all in this frame.
+  /// Execute select all in this frame.
   ///
   void(CEF_CALLBACK* select_all)(struct _cef_frame_t* self);
 
   ///
-  // Save this frame's HTML source to a temporary file and open it in the
-  // default text viewing application. This function can only be called from the
-  // browser process.
+  /// Save this frame's HTML source to a temporary file and open it in the
+  /// default text viewing application. This function can only be called from
+  /// the browser process.
   ///
   void(CEF_CALLBACK* view_source)(struct _cef_frame_t* self);
 
   ///
-  // Retrieve this frame's HTML source as a string sent to the specified
-  // visitor.
+  /// Retrieve this frame's HTML source as a string sent to the specified
+  /// visitor.
   ///
   void(CEF_CALLBACK* get_source)(struct _cef_frame_t* self,
                                  struct _cef_string_visitor_t* visitor);
 
   ///
-  // Retrieve this frame's display text as a string sent to the specified
-  // visitor.
+  /// Retrieve this frame's display text as a string sent to the specified
+  /// visitor.
   ///
   void(CEF_CALLBACK* get_text)(struct _cef_frame_t* self,
                                struct _cef_string_visitor_t* visitor);
 
   ///
-  // Load the request represented by the |request| object.
-  //
-  // WARNING: This function will fail with "bad IPC message" reason
-  // INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request
-  // origin using some other mechanism (LoadURL, link click, etc).
+  /// Load the request represented by the |request| object.
+  ///
+  /// WARNING: This function will fail with "bad IPC message" reason
+  /// INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request
+  /// origin using some other mechanism (LoadURL, link click, etc).
   ///
   void(CEF_CALLBACK* load_request)(struct _cef_frame_t* self,
                                    struct _cef_request_t* request);
 
   ///
-  // Load the specified |url|.
+  /// Load the specified |url|.
   ///
   void(CEF_CALLBACK* load_url)(struct _cef_frame_t* self,
                                const cef_string_t* url);
 
   ///
-  // Execute a string of JavaScript code in this frame. The |script_url|
-  // parameter is the URL where the script in question can be found, if any. The
-  // renderer may request this URL to show the developer the source of the
-  // error.  The |start_line| parameter is the base line number to use for error
-  // reporting.
+  /// Execute a string of JavaScript code in this frame. The |script_url|
+  /// parameter is the URL where the script in question can be found, if any.
+  /// The renderer may request this URL to show the developer the source of the
+  /// error.  The |start_line| parameter is the base line number to use for
+  /// error reporting.
   ///
   void(CEF_CALLBACK* execute_java_script)(struct _cef_frame_t* self,
                                           const cef_string_t* code,
@@ -158,83 +158,78 @@ typedef struct _cef_frame_t {
                                           int start_line);
 
   ///
-  // Returns true (1) if this is the main (top-level) frame.
+  /// Returns true (1) if this is the main (top-level) frame.
   ///
   int(CEF_CALLBACK* is_main)(struct _cef_frame_t* self);
 
   ///
-  // Returns true (1) if this is the focused frame.
+  /// Returns true (1) if this is the focused frame.
   ///
   int(CEF_CALLBACK* is_focused)(struct _cef_frame_t* self);
 
   ///
-  // Returns the name for this frame. If the frame has an assigned name (for
-  // example, set via the iframe "name" attribute) then that value will be
-  // returned. Otherwise a unique name will be constructed based on the frame
-  // parent hierarchy. The main (top-level) frame will always have an NULL name
-  // value.
+  /// Returns the name for this frame. If the frame has an assigned name (for
+  /// example, set via the iframe "name" attribute) then that value will be
+  /// returned. Otherwise a unique name will be constructed based on the frame
+  /// parent hierarchy. The main (top-level) frame will always have an NULL name
+  /// value.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_frame_t* self);
 
   ///
-  // Returns the globally unique identifier for this frame or < 0 if the
-  // underlying frame does not yet exist.
+  /// Returns the globally unique identifier for this frame or NULL if the
+  /// underlying frame does not yet exist.
   ///
-  int64(CEF_CALLBACK* get_identifier)(struct _cef_frame_t* self);
+  // The resulting string must be freed by calling cef_string_userfree_free().
+  cef_string_userfree_t(CEF_CALLBACK* get_identifier)(
+      struct _cef_frame_t* self);
 
   ///
-  // Returns the parent of this frame or NULL if this is the main (top-level)
-  // frame.
+  /// Returns the parent of this frame or NULL if this is the main (top-level)
+  /// frame.
   ///
   struct _cef_frame_t*(CEF_CALLBACK* get_parent)(struct _cef_frame_t* self);
 
   ///
-  // Returns the URL currently loaded in this frame.
+  /// Returns the URL currently loaded in this frame.
   ///
   // The resulting string must be freed by calling cef_string_userfree_free().
   cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_frame_t* self);
 
   ///
-  // Returns the browser that this frame belongs to.
+  /// Returns the browser that this frame belongs to.
   ///
   struct _cef_browser_t*(CEF_CALLBACK* get_browser)(struct _cef_frame_t* self);
 
   ///
-  // Get the V8 context associated with the frame. This function can only be
-  // called from the render process.
+  /// Get the V8 context associated with the frame. This function can only be
+  /// called from the render process.
   ///
   struct _cef_v8context_t*(CEF_CALLBACK* get_v8context)(
       struct _cef_frame_t* self);
 
   ///
-  // Visit the DOM document. This function can only be called from the render
-  // process.
+  /// Visit the DOM document. This function can only be called from the render
+  /// process.
   ///
   void(CEF_CALLBACK* visit_dom)(struct _cef_frame_t* self,
                                 struct _cef_domvisitor_t* visitor);
 
   ///
-  // Create a new URL request that will be treated as originating from this
-  // frame and the associated browser. This request may be intercepted by the
-  // client via cef_resource_request_handler_t or cef_scheme_handler_factory_t.
-  // Use cef_urlrequest_t::Create instead if you do not want the request to have
-  // this association, in which case it may be handled differently (see
-  // documentation on that function). Requests may originate from both the
-  // browser process and the render process.
-  //
-  // For requests originating from the browser process:
-  //   - POST data may only contain a single element of type PDE_TYPE_FILE or
-  //     PDE_TYPE_BYTES.
-  // For requests originating from the render process:
-  //   - POST data may only contain a single element of type PDE_TYPE_BYTES.
-  //   - If the response contains Content-Disposition or Mime-Type header values
-  //     that would not normally be rendered then the response may receive
-  //     special handling inside the browser (for example, via the file download
-  //     code path instead of the URL request code path).
-  //
-  // The |request| object will be marked as read-only after calling this
-  // function.
+  /// Create a new URL request that will be treated as originating from this
+  /// frame and the associated browser. Use cef_urlrequest_t::Create instead if
+  /// you do not want the request to have this association, in which case it may
+  /// be handled differently (see documentation on that function). A request
+  /// created with this function may only originate from the browser process,
+  /// and will behave as follows:
+  ///   - It may be intercepted by the client via CefResourceRequestHandler or
+  ///     CefSchemeHandlerFactory.
+  ///   - POST data may only contain a single element of type PDE_TYPE_FILE or
+  ///     PDE_TYPE_BYTES.
+  ///
+  /// The |request| object will be marked as read-only after calling this
+  /// function.
   ///
   struct _cef_urlrequest_t*(CEF_CALLBACK* create_urlrequest)(
       struct _cef_frame_t* self,
@@ -242,12 +237,12 @@ typedef struct _cef_frame_t {
       struct _cef_urlrequest_client_t* client);
 
   ///
-  // Send a message to the specified |target_process|. Ownership of the message
-  // contents will be transferred and the |message| reference will be
-  // invalidated. Message delivery is not guaranteed in all cases (for example,
-  // if the browser is closing, navigating, or if the target process crashes).
-  // Send an ACK message back from the target process if confirmation is
-  // required.
+  /// Send a message to the specified |target_process|. Ownership of the message
+  /// contents will be transferred and the |message| reference will be
+  /// invalidated. Message delivery is not guaranteed in all cases (for example,
+  /// if the browser is closing, navigating, or if the target process crashes).
+  /// Send an ACK message back from the target process if confirmation is
+  /// required.
   ///
   void(CEF_CALLBACK* send_process_message)(
       struct _cef_frame_t* self,

include/capi/cef_frame_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=8f791b2d1d5bea27f9e6ca5e0db731a0a76d181c$
+// $hash=fc6fbee765ce2b649f5293c8c4b076d36014e4aa$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_
@@ -49,107 +49,106 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to cef_frame_t life span.
-// The order of callbacks is:
-//
-// (1) During initial cef_browser_host_t creation and navigation of the main
-// frame: - cef_frame_handler_t::OnFrameCreated => The initial main frame object
-// has been
-//   created. Any commands will be queued until the frame is attached.
-// - cef_frame_handler_t::OnMainFrameChanged => The initial main frame object
-// has
-//   been assigned to the browser.
-// - cef_life_span_handler_t::OnAfterCreated => The browser is now valid and can
-// be
-//   used.
-// - cef_frame_handler_t::OnFrameAttached => The initial main frame object is
-// now
-//   connected to its peer in the renderer process. Commands can be routed.
-//
-// (2) During further cef_browser_host_t navigation/loading of the main frame
-// and/or sub-frames: - cef_frame_handler_t::OnFrameCreated => A new main frame
-// or sub-frame object has
-//   been created. Any commands will be queued until the frame is attached.
-// - cef_frame_handler_t::OnFrameAttached => A new main frame or sub-frame
-// object is
-//   now connected to its peer in the renderer process. Commands can be routed.
-// - cef_frame_handler_t::OnFrameDetached => An existing main frame or sub-frame
-//   object has lost its connection to the renderer process. If multiple objects
-//   are detached at the same time then notifications will be sent for any
-//   sub-frame objects before the main frame object. Commands can no longer be
-//   routed and will be discarded.
-// - cef_frame_handler_t::OnMainFrameChanged => A new main frame object has been
-//   assigned to the browser. This will only occur with cross-origin navigation
-//   or re-navigation after renderer process termination (due to crashes, etc).
-//
-// (3) During final cef_browser_host_t destruction of the main frame: -
-// cef_frame_handler_t::OnFrameDetached => Any sub-frame objects have lost their
-//   connection to the renderer process. Commands can no longer be routed and
-//   will be discarded.
-// - cef_life_span_handler_t::OnBeforeClose => The browser has been destroyed. -
-// cef_frame_handler_t::OnFrameDetached => The main frame object have lost its
-//   connection to the renderer process. Notifications will be sent for any
-//   sub-frame objects before the main frame object. Commands can no longer be
-//   routed and will be discarded.
-// - cef_frame_handler_t::OnMainFrameChanged => The final main frame object has
-// been
-//   removed from the browser.
-//
-// Cross-origin navigation and/or loading receives special handling.
-//
-// When the main frame navigates to a different origin the OnMainFrameChanged
-// callback (2) will be executed with the old and new main frame objects.
-//
-// When a new sub-frame is loaded in, or an existing sub-frame is navigated to,
-// a different origin from the parent frame, a temporary sub-frame object will
-// first be created in the parent's renderer process. That temporary sub-frame
-// will then be discarded after the real cross-origin sub-frame is created in
-// the new/target renderer process. The client will receive cross-origin
-// navigation callbacks (2) for the transition from the temporary sub-frame to
-// the real sub-frame. The temporary sub-frame will not recieve or execute
-// commands during this transitional period (any sent commands will be
-// discarded).
-//
-// When a new popup browser is created in a different origin from the parent
-// browser, a temporary main frame object for the popup will first be created in
-// the parent's renderer process. That temporary main frame will then be
-// discarded after the real cross-origin main frame is created in the new/target
-// renderer process. The client will recieve creation and initial navigation
-// callbacks (1) for the temporary main frame, followed by cross-origin
-// navigation callbacks (2) for the transition from the temporary main frame to
-// the real main frame. The temporary main frame may receive and execute
-// commands during this transitional period (any sent commands may be executed,
-// but the behavior is potentially undesirable since they execute in the parent
-// browser's renderer process and not the new/target renderer process).
-//
-// Callbacks will not be executed for placeholders that may be created during
-// pre-commit navigation for sub-frames that do not yet exist in the renderer
-// process. Placeholders will have cef_frame_t::get_identifier() == -4.
-//
-// The functions of this structure will be called on the UI thread unless
-// otherwise indicated.
+/// Implement this structure to handle events related to cef_frame_t life span.
+/// The order of callbacks is:
+///
+/// (1) During initial cef_browser_host_t creation and navigation of the main
+/// frame:
+/// - cef_frame_handler_t::OnFrameCreated => The initial main frame object has
+///   been created. Any commands will be queued until the frame is attached.
+/// - cef_frame_handler_t::OnMainFrameChanged => The initial main frame object
+///   has been assigned to the browser.
+/// - cef_life_span_handler_t::OnAfterCreated => The browser is now valid and
+///   can be used.
+/// - cef_frame_handler_t::OnFrameAttached => The initial main frame object is
+///   now connected to its peer in the renderer process. Commands can be routed.
+///
+/// (2) During further cef_browser_host_t navigation/loading of the main frame
+///     and/or sub-frames:
+/// - cef_frame_handler_t::OnFrameCreated => A new main frame or sub-frame
+///   object has been created. Any commands will be queued until the frame is
+///   attached.
+/// - cef_frame_handler_t::OnFrameAttached => A new main frame or sub-frame
+///   object is now connected to its peer in the renderer process. Commands can
+///   be routed.
+/// - cef_frame_handler_t::OnFrameDetached => An existing main frame or sub-
+///   frame object has lost its connection to the renderer process. If multiple
+///   objects are detached at the same time then notifications will be sent for
+///   any sub-frame objects before the main frame object. Commands can no longer
+///   be routed and will be discarded.
+/// - cef_frame_handler_t::OnMainFrameChanged => A new main frame object has
+///   been assigned to the browser. This will only occur with cross-origin
+///   navigation or re-navigation after renderer process termination (due to
+///   crashes, etc).
+///
+/// (3) During final cef_browser_host_t destruction of the main frame:
+/// - cef_frame_handler_t::OnFrameDetached => Any sub-frame objects have lost
+///   their connection to the renderer process. Commands can no longer be routed
+///   and will be discarded.
+/// - cef_life_span_handler_t::OnBeforeClose => The browser has been destroyed.
+/// - cef_frame_handler_t::OnFrameDetached => The main frame object have lost
+///   its connection to the renderer process. Notifications will be sent for any
+///   sub-frame objects before the main frame object. Commands can no longer be
+///   routed and will be discarded.
+/// - cef_frame_handler_t::OnMainFrameChanged => The final main frame object has
+///   been removed from the browser.
+///
+/// Cross-origin navigation and/or loading receives special handling.
+///
+/// When the main frame navigates to a different origin the OnMainFrameChanged
+/// callback (2) will be executed with the old and new main frame objects.
+///
+/// When a new sub-frame is loaded in, or an existing sub-frame is navigated to,
+/// a different origin from the parent frame, a temporary sub-frame object will
+/// first be created in the parent's renderer process. That temporary sub-frame
+/// will then be discarded after the real cross-origin sub-frame is created in
+/// the new/target renderer process. The client will receive cross-origin
+/// navigation callbacks (2) for the transition from the temporary sub-frame to
+/// the real sub-frame. The temporary sub-frame will not receive or execute
+/// commands during this transitional period (any sent commands will be
+/// discarded).
+///
+/// When a new popup browser is created in a different origin from the parent
+/// browser, a temporary main frame object for the popup will first be created
+/// in the parent's renderer process. That temporary main frame will then be
+/// discarded after the real cross-origin main frame is created in the
+/// new/target renderer process. The client will receive creation and initial
+/// navigation callbacks (1) for the temporary main frame, followed by cross-
+/// origin navigation callbacks (2) for the transition from the temporary main
+/// frame to the real main frame. The temporary main frame may receive and
+/// execute commands during this transitional period (any sent commands may be
+/// executed, but the behavior is potentially undesirable since they execute in
+/// the parent browser's renderer process and not the new/target renderer
+/// process).
+///
+/// Callbacks will not be executed for placeholders that may be created during
+/// pre-commit navigation for sub-frames that do not yet exist in the renderer
+/// process. Placeholders will have cef_frame_t::get_identifier() == -4.
+///
+/// The functions of this structure will be called on the UI thread unless
+/// otherwise indicated.
 ///
 typedef struct _cef_frame_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called when a new frame is created. This will be the first notification
-  // that references |frame|. Any commands that require transport to the
-  // associated renderer process (LoadRequest, SendProcessMessage, GetSource,
-  // etc.) will be queued until OnFrameAttached is called for |frame|.
+  /// Called when a new frame is created. This will be the first notification
+  /// that references |frame|. Any commands that require transport to the
+  /// associated renderer process (LoadRequest, SendProcessMessage, GetSource,
+  /// etc.) will be queued until OnFrameAttached is called for |frame|.
   ///
   void(CEF_CALLBACK* on_frame_created)(struct _cef_frame_handler_t* self,
                                        struct _cef_browser_t* browser,
                                        struct _cef_frame_t* frame);
 
   ///
-  // Called when a frame can begin routing commands to/from the associated
-  // renderer process. |reattached| will be true (1) if the frame was re-
-  // attached after exiting the BackForwardCache. Any commands that were queued
-  // have now been dispatched.
+  /// Called when a frame can begin routing commands to/from the associated
+  /// renderer process. |reattached| will be true (1) if the frame was re-
+  /// attached after exiting the BackForwardCache. Any commands that were queued
+  /// have now been dispatched.
   ///
   void(CEF_CALLBACK* on_frame_attached)(struct _cef_frame_handler_t* self,
                                         struct _cef_browser_t* browser,
@@ -157,29 +156,31 @@ typedef struct _cef_frame_handler_t {
                                         int reattached);
 
   ///
-  // Called when a frame loses its connection to the renderer process and will
-  // be destroyed. Any pending or future commands will be discarded and
-  // cef_frame_t::is_valid() will now return false (0) for |frame|. If called
-  // after cef_life_span_handler_t::on_before_close() during browser destruction
-  // then cef_browser_t::is_valid() will return false (0) for |browser|.
+  /// Called when a frame loses its connection to the renderer process and will
+  /// be destroyed. Any pending or future commands will be discarded and
+  /// cef_frame_t::is_valid() will now return false (0) for |frame|. If called
+  /// after cef_life_span_handler_t::on_before_close() during browser
+  /// destruction then cef_browser_t::is_valid() will return false (0) for
+  /// |browser|.
   ///
   void(CEF_CALLBACK* on_frame_detached)(struct _cef_frame_handler_t* self,
                                         struct _cef_browser_t* browser,
                                         struct _cef_frame_t* frame);
 
   ///
-  // Called when the main frame changes due to (a) initial browser creation, (b)
-  // final browser destruction, (c) cross-origin navigation or (d) re-navigation
-  // after renderer process termination (due to crashes, etc). |old_frame| will
-  // be NULL and |new_frame| will be non-NULL when a main frame is assigned to
-  // |browser| for the first time. |old_frame| will be non-NULL and |new_frame|
-  // will be NULL and  when a main frame is removed from |browser| for the last
-  // time. Both |old_frame| and |new_frame| will be non-NULL for cross-origin
-  // navigations or re-navigation after renderer process termination. This
-  // function will be called after on_frame_created() for |new_frame| and/or
-  // after on_frame_detached() for |old_frame|. If called after
-  // cef_life_span_handler_t::on_before_close() during browser destruction then
-  // cef_browser_t::is_valid() will return false (0) for |browser|.
+  /// Called when the main frame changes due to (a) initial browser creation,
+  /// (b) final browser destruction, (c) cross-origin navigation or (d) re-
+  /// navigation after renderer process termination (due to crashes, etc).
+  /// |old_frame| will be NULL and |new_frame| will be non-NULL when a main
+  /// frame is assigned to |browser| for the first time. |old_frame| will be
+  /// non-NULL and |new_frame| will be NULL and  when a main frame is removed
+  /// from |browser| for the last time. Both |old_frame| and |new_frame| will be
+  /// non-NULL for cross-origin navigations or re-navigation after renderer
+  /// process termination. This function will be called after on_frame_created()
+  /// for |new_frame| and/or after on_frame_detached() for |old_frame|. If
+  /// called after cef_life_span_handler_t::on_before_close() during browser
+  /// destruction then cef_browser_t::is_valid() will return false (0) for
+  /// |browser|.
   ///
   void(CEF_CALLBACK* on_main_frame_changed)(struct _cef_frame_handler_t* self,
                                             struct _cef_browser_t* browser,

include/capi/cef_i18n_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c063e5f0e0c9fef71bdb56e7cc3ea775de17a3ea$
+// $hash=990e80ab5ae04298e6b70cbc0a67115825563251$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
@@ -47,7 +47,7 @@ extern "C" {
 #endif
 
 ///
-// Returns true (1) if the application text direction is right-to-left.
+/// Returns true (1) if the application text direction is right-to-left.
 ///
 CEF_EXPORT int cef_is_rtl(void);
 

include/capi/cef_image_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=bbc87eb4ecaf92c900193afef7059caedbe8ab3a$
+// $hash=7512ccf755017d5b1866b753890b498e8163006d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
@@ -48,37 +48,37 @@ extern "C" {
 #endif
 
 ///
-// Container for a single image represented at different scale factors. All
-// image representations should be the same size in density independent pixel
-// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
-// then the image at scale factor 2.0 should be 200x200 pixels -- both images
-// will display with a DIP size of 100x100 units. The functions of this
-// structure can be called on any browser process thread.
+/// Container for a single image represented at different scale factors. All
+/// image representations should be the same size in density independent pixel
+/// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
+/// then the image at scale factor 2.0 should be 200x200 pixels -- both images
+/// will display with a DIP size of 100x100 units. The functions of this
+/// structure can be called on any browser process thread.
 ///
 typedef struct _cef_image_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Returns true (1) if this Image is NULL.
+  /// Returns true (1) if this Image is NULL.
   ///
   int(CEF_CALLBACK* is_empty)(struct _cef_image_t* self);
 
   ///
-  // Returns true (1) if this Image and |that| Image share the same underlying
-  // storage. Will also return true (1) if both images are NULL.
+  /// Returns true (1) if this Image and |that| Image share the same underlying
+  /// storage. Will also return true (1) if both images are NULL.
   ///
   int(CEF_CALLBACK* is_same)(struct _cef_image_t* self,
                              struct _cef_image_t* that);
 
   ///
-  // Add a bitmap image representation for |scale_factor|. Only 32-bit RGBA/BGRA
-  // formats are supported. |pixel_width| and |pixel_height| are the bitmap
-  // representation size in pixel coordinates. |pixel_data| is the array of
-  // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
-  // |color_type| and |alpha_type| values specify the pixel format.
+  /// Add a bitmap image representation for |scale_factor|. Only 32-bit
+  /// RGBA/BGRA formats are supported. |pixel_width| and |pixel_height| are the
+  /// bitmap representation size in pixel coordinates. |pixel_data| is the array
+  /// of pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in
+  /// size. |color_type| and |alpha_type| values specify the pixel format.
   ///
   int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self,
                                 float scale_factor,
@@ -90,9 +90,9 @@ typedef struct _cef_image_t {
                                 size_t pixel_data_size);
 
   ///
-  // Add a PNG image representation for |scale_factor|. |png_data| is the image
-  // data of size |png_data_size|. Any alpha transparency in the PNG data will
-  // be maintained.
+  /// Add a PNG image representation for |scale_factor|. |png_data| is the image
+  /// data of size |png_data_size|. Any alpha transparency in the PNG data will
+  /// be maintained.
   ///
   int(CEF_CALLBACK* add_png)(struct _cef_image_t* self,
                              float scale_factor,
@@ -100,9 +100,9 @@ typedef struct _cef_image_t {
                              size_t png_data_size);
 
   ///
-  // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
-  // image data of size |jpeg_data_size|. The JPEG format does not support
-  // transparency so the alpha byte will be set to 0xFF for all pixels.
+  /// Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
+  /// image data of size |jpeg_data_size|. The JPEG format does not support
+  /// transparency so the alpha byte will be set to 0xFF for all pixels.
   ///
   int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self,
                               float scale_factor,
@@ -110,33 +110,34 @@ typedef struct _cef_image_t {
                               size_t jpeg_data_size);
 
   ///
-  // Returns the image width in density independent pixel (DIP) units.
+  /// Returns the image width in density independent pixel (DIP) units.
   ///
   size_t(CEF_CALLBACK* get_width)(struct _cef_image_t* self);
 
   ///
-  // Returns the image height in density independent pixel (DIP) units.
+  /// Returns the image height in density independent pixel (DIP) units.
   ///
   size_t(CEF_CALLBACK* get_height)(struct _cef_image_t* self);
 
   ///
-  // Returns true (1) if this image contains a representation for
-  // |scale_factor|.
+  /// Returns true (1) if this image contains a representation for
+  /// |scale_factor|.
   ///
   int(CEF_CALLBACK* has_representation)(struct _cef_image_t* self,
                                         float scale_factor);
 
   ///
-  // Removes the representation for |scale_factor|. Returns true (1) on success.
+  /// Removes the representation for |scale_factor|. Returns true (1) on
+  /// success.
   ///
   int(CEF_CALLBACK* remove_representation)(struct _cef_image_t* self,
                                            float scale_factor);
 
   ///
-  // Returns information for the representation that most closely matches
-  // |scale_factor|. |actual_scale_factor| is the actual scale factor for the
-  // representation. |pixel_width| and |pixel_height| are the representation
-  // size in pixel coordinates. Returns true (1) on success.
+  /// Returns information for the representation that most closely matches
+  /// |scale_factor|. |actual_scale_factor| is the actual scale factor for the
+  /// representation. |pixel_width| and |pixel_height| are the representation
+  /// size in pixel coordinates. Returns true (1) on success.
   ///
   int(CEF_CALLBACK* get_representation_info)(struct _cef_image_t* self,
                                              float scale_factor,
@@ -145,12 +146,12 @@ typedef struct _cef_image_t {
                                              int* pixel_height);
 
   ///
-  // Returns the bitmap representation that most closely matches |scale_factor|.
-  // Only 32-bit RGBA/BGRA formats are supported. |color_type| and |alpha_type|
-  // values specify the desired output pixel format. |pixel_width| and
-  // |pixel_height| are the output representation size in pixel coordinates.
-  // Returns a cef_binary_value_t containing the pixel data on success or NULL
-  // on failure.
+  /// Returns the bitmap representation that most closely matches
+  /// |scale_factor|. Only 32-bit RGBA/BGRA formats are supported. |color_type|
+  /// and |alpha_type| values specify the desired output pixel format.
+  /// |pixel_width| and |pixel_height| are the output representation size in
+  /// pixel coordinates. Returns a cef_binary_value_t containing the pixel data
+  /// on success or NULL on failure.
   ///
   struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)(
       struct _cef_image_t* self,
@@ -161,12 +162,12 @@ typedef struct _cef_image_t {
       int* pixel_height);
 
   ///
-  // Returns the PNG representation that most closely matches |scale_factor|. If
-  // |with_transparency| is true (1) any alpha transparency in the image will be
-  // represented in the resulting PNG data. |pixel_width| and |pixel_height| are
-  // the output representation size in pixel coordinates. Returns a
-  // cef_binary_value_t containing the PNG image data on success or NULL on
-  // failure.
+  /// Returns the PNG representation that most closely matches |scale_factor|.
+  /// If |with_transparency| is true (1) any alpha transparency in the image
+  /// will be represented in the resulting PNG data. |pixel_width| and
+  /// |pixel_height| are the output representation size in pixel coordinates.
+  /// Returns a cef_binary_value_t containing the PNG image data on success or
+  /// NULL on failure.
   ///
   struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)(
       struct _cef_image_t* self,
@@ -176,13 +177,13 @@ typedef struct _cef_image_t {
       int* pixel_height);
 
   ///
-  // Returns the JPEG representation that most closely matches |scale_factor|.
-  // |quality| determines the compression level with 0 == lowest and 100 ==
-  // highest. The JPEG format does not support alpha transparency and the alpha
-  // channel, if any, will be discarded. |pixel_width| and |pixel_height| are
-  // the output representation size in pixel coordinates. Returns a
-  // cef_binary_value_t containing the JPEG image data on success or NULL on
-  // failure.
+  /// Returns the JPEG representation that most closely matches |scale_factor|.
+  /// |quality| determines the compression level with 0 == lowest and 100 ==
+  /// highest. The JPEG format does not support alpha transparency and the alpha
+  /// channel, if any, will be discarded. |pixel_width| and |pixel_height| are
+  /// the output representation size in pixel coordinates. Returns a
+  /// cef_binary_value_t containing the JPEG image data on success or NULL on
+  /// failure.
   ///
   struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)(
       struct _cef_image_t* self,
@@ -193,8 +194,8 @@ typedef struct _cef_image_t {
 } cef_image_t;
 
 ///
-// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
-// to add representations at different scale factors.
+/// Create a new cef_image_t. It will initially be NULL. Use the Add*()
+/// functions to add representations at different scale factors.
 ///
 CEF_EXPORT cef_image_t* cef_image_create(void);
 

include/capi/cef_jsdialog_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c68332a779bab425aa2e6a858d20a43448631890$
+// $hash=c6810367ba3a17824247dcb17f87040cd021c295$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
@@ -48,18 +48,19 @@ extern "C" {
 #endif
 
 ///
-// Callback structure used for asynchronous continuation of JavaScript dialog
-// requests.
+/// Callback structure used for asynchronous continuation of JavaScript dialog
+/// requests.
 ///
 typedef struct _cef_jsdialog_callback_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Continue the JS dialog request. Set |success| to true (1) if the OK button
-  // was pressed. The |user_input| value should be specified for prompt dialogs.
+  /// Continue the JS dialog request. Set |success| to true (1) if the OK button
+  /// was pressed. The |user_input| value should be specified for prompt
+  /// dialogs.
   ///
   void(CEF_CALLBACK* cont)(struct _cef_jsdialog_callback_t* self,
                            int success,
@@ -67,31 +68,31 @@ typedef struct _cef_jsdialog_callback_t {
 } cef_jsdialog_callback_t;
 
 ///
-// Implement this structure to handle events related to JavaScript dialogs. The
-// functions of this structure will be called on the UI thread.
+/// Implement this structure to handle events related to JavaScript dialogs. The
+/// functions of this structure will be called on the UI thread.
 ///
 typedef struct _cef_jsdialog_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
-  // passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
-  // and user-friendly display string. The |default_prompt_text| value will be
-  // specified for prompt dialogs only. Set |suppress_message| to true (1) and
-  // return false (0) to suppress the message (suppressing messages is
-  // preferable to immediately executing the callback as this is used to detect
-  // presumably malicious behavior like spamming alert messages in
-  // onbeforeunload). Set |suppress_message| to false (0) and return false (0)
-  // to use the default implementation (the default implementation will show one
-  // modal dialog at a time and suppress any additional dialog requests until
-  // the displayed dialog is dismissed). Return true (1) if the application will
-  // use a custom dialog or if the callback has been executed immediately.
-  // Custom dialogs may be either modal or modeless. If a custom dialog is used
-  // the application must execute |callback| once the custom dialog is
-  // dismissed.
+  /// Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
+  /// passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
+  /// and user-friendly display string. The |default_prompt_text| value will be
+  /// specified for prompt dialogs only. Set |suppress_message| to true (1) and
+  /// return false (0) to suppress the message (suppressing messages is
+  /// preferable to immediately executing the callback as this is used to detect
+  /// presumably malicious behavior like spamming alert messages in
+  /// onbeforeunload). Set |suppress_message| to false (0) and return false (0)
+  /// to use the default implementation (the default implementation will show
+  /// one modal dialog at a time and suppress any additional dialog requests
+  /// until the displayed dialog is dismissed). Return true (1) if the
+  /// application will use a custom dialog or if the callback has been executed
+  /// immediately. Custom dialogs may be either modal or modeless. If a custom
+  /// dialog is used the application must execute |callback| once the custom
+  /// dialog is dismissed.
   ///
   int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self,
                                  struct _cef_browser_t* browser,
@@ -103,12 +104,12 @@ typedef struct _cef_jsdialog_handler_t {
                                  int* suppress_message);
 
   ///
-  // Called to run a dialog asking the user if they want to leave a page. Return
-  // false (0) to use the default dialog implementation. Return true (1) if the
-  // application will use a custom dialog or if the callback has been executed
-  // immediately. Custom dialogs may be either modal or modeless. If a custom
-  // dialog is used the application must execute |callback| once the custom
-  // dialog is dismissed.
+  /// Called to run a dialog asking the user if they want to leave a page.
+  /// Return false (0) to use the default dialog implementation. Return true (1)
+  /// if the application will use a custom dialog or if the callback has been
+  /// executed immediately. Custom dialogs may be either modal or modeless. If a
+  /// custom dialog is used the application must execute |callback| once the
+  /// custom dialog is dismissed.
   ///
   int(CEF_CALLBACK* on_before_unload_dialog)(
       struct _cef_jsdialog_handler_t* self,
@@ -118,16 +119,16 @@ typedef struct _cef_jsdialog_handler_t {
       struct _cef_jsdialog_callback_t* callback);
 
   ///
-  // Called to cancel any pending dialogs and reset any saved dialog state. Will
-  // be called due to events like page navigation irregardless of whether any
-  // dialogs are currently pending.
+  /// Called to cancel any pending dialogs and reset any saved dialog state.
+  /// Will be called due to events like page navigation irregardless of whether
+  /// any dialogs are currently pending.
   ///
   void(CEF_CALLBACK* on_reset_dialog_state)(
       struct _cef_jsdialog_handler_t* self,
       struct _cef_browser_t* browser);
 
   ///
-  // Called when the default implementation dialog is closed.
+  /// Called when the dialog is closed.
   ///
   void(CEF_CALLBACK* on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
                                        struct _cef_browser_t* browser);

include/capi/cef_keyboard_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=140d3a3ce78f5e8ab50a24a2fd6377e7a8ea3256$
+// $hash=0bfe161c51cc6378b2e8e2e2b2c017b750b46864$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
@@ -48,37 +48,38 @@ extern "C" {
 #endif
 
 ///
-// Implement this structure to handle events related to keyboard input. The
-// functions of this structure will be called on the UI thread.
+/// Implement this structure to handle events related to keyboard input. The
+/// functions of this structure will be called on the UI thread.
 ///
 typedef struct _cef_keyboard_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called before a keyboard event is sent to the renderer. |event| contains
-  // information about the keyboard event. |os_event| is the operating system
-  // event message, if any. Return true (1) if the event was handled or false
-  // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
-  // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
+  /// Called before a keyboard event is sent to the renderer. |event| contains
+  /// information about the keyboard event. |os_event| is the operating system
+  /// event message, if any. Return true (1) if the event was handled or false
+  /// (0) otherwise. If the event will be handled in on_key_event() as a
+  /// keyboard shortcut set |is_keyboard_shortcut| to true (1) and return false
+  /// (0).
   ///
   int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self,
                                       struct _cef_browser_t* browser,
-                                      const struct _cef_key_event_t* event,
+                                      const cef_key_event_t* event,
                                       cef_event_handle_t os_event,
                                       int* is_keyboard_shortcut);
 
   ///
-  // Called after the renderer and JavaScript in the page has had a chance to
-  // handle the event. |event| contains information about the keyboard event.
-  // |os_event| is the operating system event message, if any. Return true (1)
-  // if the keyboard event was handled or false (0) otherwise.
+  /// Called after the renderer and JavaScript in the page has had a chance to
+  /// handle the event. |event| contains information about the keyboard event.
+  /// |os_event| is the operating system event message, if any. Return true (1)
+  /// if the keyboard event was handled or false (0) otherwise.
   ///
   int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self,
                                   struct _cef_browser_t* browser,
-                                  const struct _cef_key_event_t* event,
+                                  const cef_key_event_t* event,
                                   cef_event_handle_t os_event);
 } cef_keyboard_handler_t;
 

include/capi/cef_life_span_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2024 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=34a6559587adbd0dc3143989a8c6e49e0664b43e$
+// $hash=6aad2ccf30a6c519bbeee64d83866e82a41a48d8$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@@ -50,40 +50,40 @@ extern "C" {
 struct _cef_client_t;
 
 ///
-// Implement this structure to handle events related to browser life span. The
-// functions of this structure will be called on the UI thread unless otherwise
-// indicated.
+/// Implement this structure to handle events related to browser life span. The
+/// functions of this structure will be called on the UI thread unless otherwise
+/// indicated.
 ///
 typedef struct _cef_life_span_handler_t {
   ///
-  // Base structure.
+  /// Base structure.
   ///
   cef_base_ref_counted_t base;
 
   ///
-  // Called on the UI thread before a new popup browser is created. The
-  // |browser| and |frame| values represent the source of the popup request. The
-  // |target_url| and |target_frame_name| values indicate where the popup
-  // browser should navigate and may be NULL if not specified with the request.
-  // The |target_disposition| value indicates where the user intended to open
-  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
-  // be true (1) if the popup was opened via explicit user gesture (e.g.
-  // clicking a link) or false (0) if the popup opened automatically (e.g. via
-  // the DomContentLoaded event). The |popupFeatures| structure contains
-  // additional information about the requested popup window. To allow creation
-  // of the popup browser optionally modify |windowInfo|, |client|, |settings|
-  // and |no_javascript_access| and return false (0). To cancel creation of the
-  // popup browser return true (1). The |client| and |settings| values will
-  // default to the source browser's values. If the |no_javascript_access| value
-  // is set to false (0) the new browser will not be scriptable and may not be
-  // hosted in the same renderer process as the source browser. Any
-  // modifications to |windowInfo| will be ignored if the parent browser is
-  // wrapped in a cef_browser_view_t. Popup browser creation will be canceled if
-  // the parent browser is destroyed before the popup browser creation completes
-  // (indicated by a call to OnAfterCreated for the popup browser). The
-  // |extra_info| parameter provides an opportunity to specify extra information
-  // specific to the created popup browser that will be passed to
-  // cef_render_process_handler_t::on_browser_created() in the render process.
+  /// Called on the UI thread before a new popup browser is created. The
+  /// |browser| and |frame| values represent the source of the popup request.
+  /// The |target_url| and |target_frame_name| values indicate where the popup
+  /// browser should navigate and may be NULL if not specified with the request.
+  /// The |target_disposition| value indicates where the user intended to open
+  /// the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+  /// be true (1) if the popup was opened via explicit user gesture (e.g.
+  /// clicking a link) or false (0) if the popup opened automatically (e.g. via
+  /// the DomContentLoaded event). The |popupFeatures| structure contains
+  /// additional information about the requested popup window. To allow creation
+  /// of the popup browser optionally modify |windowInfo|, |client|, |settings|
+  /// and |no_javascript_access| and return false (0). To cancel creation of the
+  /// popup browser return true (1). The |client| and |settings| values will
+  /// default to the source browser's values. If the |no_javascript_access|
+  /// value is set to false (0) the new browser will not be scriptable and may
+  /// not be hosted in the same renderer process as the source browser. Any
+  /// modifications to |windowInfo| will be ignored if the parent browser is
+  /// wrapped in a cef_browser_view_t. Popup browser creation will be canceled
+  /// if the parent browser is destroyed before the popup browser creation
+  /// completes (indicated by a call to OnAfterCreated for the popup browser).
+  /// The |extra_info| parameter provides an opportunity to specify extra
+  /// information specific to the created popup browser that will be passed to
+  /// cef_render_process_handler_t::on_browser_created() in the render process.
   ///
   int(CEF_CALLBACK* on_before_popup)(
       struct _cef_life_span_handler_t* self,
@@ -93,7 +93,7 @@ typedef struct _cef_life_span_handler_t {
       const cef_string_t* target_frame_name,
       cef_window_open_disposition_t target_disposition,
       int user_gesture,
-      const struct _cef_popup_features_t* popupFeatures,
+      const cef_popup_features_t* popupFeatures,
       struct _cef_window_info_t* windowInfo,
       struct _cef_client_t** client,
       struct _cef_browser_settings_t* settings,
@@ -101,117 +101,163 @@ typedef struct _cef_life_span_handler_t {
       int* no_javascript_access);
 
   ///
-  // Called after a new browser is created. It is now safe to begin performing
-  // actions with |browser|. cef_frame_handler_t callbacks related to initial
-  // main frame creation will arrive before this callback. See
-  // cef_frame_handler_t documentation for additional usage information.
+  /// Called on the UI thread before a new DevTools popup browser is created.
+  /// The |browser| value represents the source of the popup request. Optionally
+  /// modify |windowInfo|, |client|, |settings| and |extra_info| values. The
+  /// |client|, |settings| and |extra_info| values will default to the source
+  /// browser's values. Any modifications to |windowInfo| will be ignored if the
+  /// parent browser is Views-hosted (wrapped in a cef_browser_view_t).
+  ///
+  /// The |extra_info| parameter provides an opportunity to specify extra
+  /// information specific to the created popup browser that will be passed to
+  /// cef_render_process_handler_t::on_browser_created() in the render process.
+  /// The existing |extra_info| object, if any, will be read-only but may be
+  /// replaced with a new object.
+  ///
+  /// Views-hosted source browsers will create Views-hosted DevTools popups
+  /// unless |use_default_window| is set to to true (1). DevTools popups can be
+  /// blocked by returning true (1) from cef_command_handler_t::OnChromeCommand
+  /// for IDC_DEV_TOOLS. Only used with Chrome style.
+  ///
+  void(CEF_CALLBACK* on_before_dev_tools_popup)(
+      struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_window_info_t* windowInfo,
+      struct _cef_client_t** client,
+      struct _cef_browser_settings_t* settings,
+      struct _cef_dictionary_value_t** extra_info,
+      int* use_default_window);
+
+  ///
+  /// Called after a new browser is created. It is now safe to begin performing
+  /// actions with |browser|. cef_frame_handler_t callbacks related to initial
+  /// main frame creation will arrive before this callback. See
+  /// cef_frame_handler_t documentation for additional usage information.
   ///
   void(CEF_CALLBACK* on_after_created)(struct _cef_life_span_handler_t* self,
                                        struct _cef_browser_t* browser);
 
   ///
-  // Called when a browser has recieved a request to close. This may result
-  // directly from a call to cef_browser_host_t::*close_browser() or indirectly
-  // if the browser is parented to a top-level window created by CEF and the
-  // user attempts to close that window (by clicking the 'X', for example). The
-  // do_close() function will be called after the JavaScript 'onunload' event
-  // has been fired.
-  //
-  // An application should handle top-level owner window close notifications by
-  // calling cef_browser_host_t::try_close_browser() or
-  // cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window
-  // to close immediately (see the examples below). This gives CEF an
-  // opportunity to process the 'onbeforeunload' event and optionally cancel the
-  // close before do_close() is called.
-  //
-  // When windowed rendering is enabled CEF will internally create a window or
-  // view to host the browser. In that case returning false (0) from do_close()
-  // will send the standard close notification to the browser's top-level owner
-  // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on
-  // Linux or cef_window_delegate_t::can_close() callback from Views). If the
-  // browser's host window/view has already been destroyed (via view hierarchy
-  // tear-down, for example) then do_close() will not be called for that browser
-  // since is no longer possible to cancel the close.
-  //
-  // When windowed rendering is disabled returning false (0) from do_close()
-  // will cause the browser object to be destroyed immediately.
-  //
-  // If the browser's top-level owner window requires a non-standard close
-  // notification then send that notification from do_close() and return true
-  // (1).
-  //
-  // The cef_life_span_handler_t::on_before_close() function will be called
-  // after do_close() (if do_close() is called) and immediately before the
-  // browser object is destroyed. The application should only exit after
-  // on_before_close() has been called for all existing browsers.
-  //
-  // The below examples describe what should happen during window close when the
-  // browser is parented to an application-provided top-level window.
-  //
-  // Example 1: Using cef_browser_host_t::try_close_browser(). This is
-  // recommended for clients using standard close handling and windows created
-  // on the browser process UI thread. 1.  User clicks the window close button
-  // which sends a close notification to
-  //     the application's top-level window.
-  // 2.  Application's top-level window receives the close notification and
-  //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
-  //     TryCloseBrowser() returns false so the client cancels the window close.
-  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
-  //     confirmation dialog (which can be overridden via
-  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
-  // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
-  // CEF sends a close notification to the application's top-level window
-  //     (because DoClose() returned false by default).
-  // 7.  Application's top-level window receives the close notification and
-  //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
-  //     allows the window close.
-  // 8.  Application's top-level window is destroyed. 9.  Application's
-  // on_before_close() handler is called and the browser object
-  //     is destroyed.
-  // 10. Application exits by calling cef_quit_message_loop() if no other
-  // browsers
-  //     exist.
-  //
-  // Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and
-  // implementing the do_close() callback. This is recommended for clients using
-  // non-standard close handling or windows that were not created on the browser
-  // process UI thread. 1.  User clicks the window close button which sends a
-  // close notification to
-  //     the application's top-level window.
-  // 2.  Application's top-level window receives the close notification and:
-  //     A. Calls CefBrowserHost::CloseBrowser(false).
-  //     B. Cancels the window close.
-  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
-  //     confirmation dialog (which can be overridden via
-  //     CefJSDialogHandler::OnBeforeUnloadDialog()).
-  // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
-  // Application's do_close() handler is called. Application will:
-  //     A. Set a flag to indicate that the next close attempt will be allowed.
-  //     B. Return false.
-  // 7.  CEF sends an close notification to the application's top-level window.
-  // 8.  Application's top-level window receives the close notification and
-  //     allows the window to close based on the flag from #6B.
-  // 9.  Application's top-level window is destroyed. 10. Application's
-  // on_before_close() handler is called and the browser object
-  //     is destroyed.
-  // 11. Application exits by calling cef_quit_message_loop() if no other
-  // browsers
-  //     exist.
+  /// Called when an Alloy style browser is ready to be closed, meaning that the
+  /// close has already been initiated and that JavaScript unload handlers have
+  /// already executed or should be ignored. This may result directly from a
+  /// call to cef_browser_host_t::[Try]close_browser() or indirectly if the
+  /// browser's top-level parent window was created by CEF and the user attempts
+  /// to close that window (by clicking the 'X', for example). do_close() will
+  /// not be called if the browser's host window/view has already been destroyed
+  /// (via parent window/view hierarchy tear-down, for example), as it is no
+  /// longer possible to customize the close behavior at that point.
+  ///
+  /// An application should handle top-level parent window close notifications
+  /// by calling cef_browser_host_t::try_close_browser() or
+  /// cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window
+  /// to close immediately (see the examples below). This gives CEF an
+  /// opportunity to process JavaScript unload handlers and optionally cancel
+  /// the close before do_close() is called.
+  ///
+  /// When windowed rendering is enabled CEF will create an internal child
+  /// window/view to host the browser. In that case returning false (0) from
+  /// do_close() will send the standard close notification to the browser's top-
+  /// level parent window (e.g. WM_CLOSE on Windows, performClose: on OS X,
+  /// "delete_event" on Linux or cef_window_delegate_t::can_close() callback
+  /// from Views).
+  ///
+  /// When windowed rendering is disabled there is no internal window/view and
+  /// returning false (0) from do_close() will cause the browser object to be
+  /// destroyed immediately.
+  ///
+  /// If the browser's top-level parent window requires a non-standard close
+  /// notification then send that notification from do_close() and return true
+  /// (1). You are still required to complete the browser close as soon as
+  /// possible (either by calling [Try]close_browser() or by proceeding with
+  /// window/view hierarchy tear-down), otherwise the browser will be left in a
+  /// partially closed state that interferes with proper functioning. Top-level
+  /// windows created on the browser process UI thread can alternately call
+  /// cef_browser_host_t::is_ready_to_be_closed() in the close handler to check
+  /// close status instead of relying on custom do_close() handling. See
+  /// documentation on that function for additional details.
+  ///
+  /// The cef_life_span_handler_t::on_before_close() function will be called
+  /// after do_close() (if do_close() is called) and immediately before the
+  /// browser object is destroyed. The application should only exit after
+  /// on_before_close() has been called for all existing browsers.
+  ///
+  /// The below examples describe what should happen during window close when
+  /// the browser is parented to an application-provided top-level window.
+  ///
+  /// Example 1: Using cef_browser_host_t::try_close_browser(). This is
+  /// recommended for clients using standard close handling and windows created
+  /// on the browser process UI thread. 1.  User clicks the window close button
+  /// which sends a close notification
+  ///     to the application's top-level window.
+  /// 2.  Application's top-level window receives the close notification and
+  ///     calls TryCloseBrowser() (similar to calling CloseBrowser(false)).
+  ///     TryCloseBrowser() returns false so the client cancels the window
+  ///     close.
+  /// 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  ///     confirmation dialog (which can be overridden via
+  ///     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  /// 4.  User approves the close. 5.  JavaScript 'onunload' handler executes.
+  /// 6.  Application's do_close() handler is called and returns false (0) by
+  ///     default.
+  /// 7.  CEF sends a close notification to the application's top-level window
+  ///     (because DoClose() returned false).
+  /// 8.  Application's top-level window receives the close notification and
+  ///     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
+  ///     allows the window close.
+  /// 9.  Application's top-level window is destroyed, triggering destruction
+  ///     of the child browser window.
+  /// 10. Application's on_before_close() handler is called and the browser
+  /// object
+  ///     is destroyed.
+  /// 11. Application exits by calling cef_quit_message_loop() if no other
+  /// browsers
+  ///     exist.
+  ///
+  /// Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and
+  /// implementing the do_close() callback. This is recommended for clients
+  /// using non-standard close handling or windows that were not created on the
+  /// browser process UI thread. 1.  User clicks the window close button which
+  /// sends a close notification
+  ///     to the application's top-level window.
+  /// 2.  Application's top-level window receives the close notification and:
+  ///     A. Calls CefBrowserHost::CloseBrowser(false).
+  ///     B. Cancels the window close.
+  /// 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+  ///     confirmation dialog (which can be overridden via
+  ///     CefJSDialogHandler::OnBeforeUnloadDialog()).
+  /// 4.  User approves the close. 5.  JavaScript 'onunload' handler executes.
+  /// 6.  Application's do_close() handler is called. Application will:
+  ///     A. Set a flag to indicate that the next top-level window close attempt
+  ///        will be allowed.
+  ///     B. Return false.
+  /// 7.  CEF sends a close notification to the application's top-level window
+  ///     (because DoClose() returned false).
+  /// 8.  Application's top-level window receives the close notification and
+  ///     allows the window to close based on the flag from #6A.
+  /// 9.  Application's top-level window is destroyed, triggering destruction
+  ///     of the child browser window.
+  /// 10. Application's on_before_close() handler is called and the browser
+  /// object
+  ///     is destroyed.
+  /// 11. Application exits by calling cef_quit_message_loop() if no other
+  /// browsers
+  ///     exist.
   ///
   int(CEF_CALLBACK* do_close)(struct _cef_life_span_handler_t* self,
                               struct _cef_browser_t* browser);
 
   ///
-  // Called just before a browser is destroyed. Release all references to the
-  // browser object and do not attempt to execute any functions on the browser
-  // object (other than IsValid, GetIdentifier or IsSame) after this callback
-  // returns. cef_frame_handler_t callbacks related to final main frame
-  // destruction will arrive after this callback and cef_browser_t::IsValid will
-  // return false (0) at that time. Any in-progress network requests associated
-  // with |browser| will be aborted when the browser is destroyed, and
-  // cef_resource_request_handler_t callbacks related to those requests may
-  // still arrive on the IO thread after this callback. See cef_frame_handler_t
-  // and do_close() documentation for additional usage information.
+  /// Called just before a browser is destroyed. Release all references to the
+  /// browser object and do not attempt to execute any functions on the browser
+  /// object (other than IsValid, GetIdentifier or IsSame) after this callback
+  /// returns. cef_frame_handler_t callbacks related to final main frame
+  /// destruction will arrive after this callback and cef_browser_t::IsValid
+  /// will return false (0) at that time. Any in-progress network requests
+  /// associated with |browser| will be aborted when the browser is destroyed,
+  /// and cef_resource_request_handler_t callbacks related to those requests may
+  /// still arrive on the IO thread after this callback. See cef_frame_handler_t
+  /// and do_close() documentation for additional usage information.
   ///
   void(CEF_CALLBACK* on_before_close)(struct _cef_life_span_handler_t* self,
                                       struct _cef_browser_t* browser);