Fix read of crash reporting env vars

Mac: Require Xcode 16.3 (16E140) and SDK 15.4 (24E241)

.gitignore.in

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

CHROMIUM_BUILD_COMPATIBILITY.txt

@@ -7,5 +7,5 @@
 # https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
 
 {
-  'chromium_checkout': 'refs/tags/127.0.6533.43'
+  'chromium_checkout': 'refs/tags/138.0.7204.0'
 }

CHROMIUM_UPDATE.txt

@@ -27,17 +27,6 @@
   # 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/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.*',

CMakeLists.txt.in

@@ -48,10 +48,9 @@
 #     libgtk3.0-dev     (required by the cefclient target only)
 #
 # - MacOS requirements:
-#   Xcode 12.2 to 15.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 2022 building on Windows 10 or newer. Windows 10/11 64-bit is
@@ -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)
 
 
 #
@@ -254,4 +253,4 @@ if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile")
   else()
     message(WARNING "Doxygen must be installed to generate API documentation.")
   endif()
-endif()
+endif()

Doxyfile

@@ -184,7 +184,13 @@ FULL_PATH_NAMES        = YES
 # will be relative from the directory where doxygen is started.
 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
 
-STRIP_FROM_PATH        =
+# CEF NOTE: Intentionally keeping the 'gen' prefix for these includes in the
+# "File List" side panel to differentiate directories.
+# See https://github.com/doxygen/doxygen/issues/8318.
+
+STRIP_FROM_PATH        = . \
+                         ../out/Release_GN_x64 \
+                         ../out/Release_GN_arm64
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
 # path mentioned in the documentation of a class, which tells the reader which
@@ -909,7 +915,9 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = README.md \
-                         include
+                         include \
+                         ../out/Release_GN_x64/gen/cef/include \
+                         ../out/Release_GN_arm64/gen/cef/include
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -2329,7 +2337,7 @@ ENABLE_PREPROCESSING   = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-MACRO_EXPANSION        = NO
+MACRO_EXPANSION        = YES
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
 # the macro expansion is limited to the macros specified with the PREDEFINED and
@@ -2337,7 +2345,7 @@ MACRO_EXPANSION        = NO
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-EXPAND_ONLY_PREDEF     = NO
+EXPAND_ONLY_PREDEF     = YES
 
 # If the SEARCH_INCLUDES tag is set to YES, the include files in the
 # INCLUDE_PATH will be searched if a #include is found.
@@ -2376,7 +2384,12 @@ PREDEFINED             = USING_CEF_SHARED \
                          OS_LINUX \
                          CEF_X11 \
                          OS_MAC \
-                         ARCH_CPU_32_BITS
+                         __OBJC__ \
+                         OS_POSIX \
+                         ARCH_CPU_32_BITS \
+                         CEF_API_ADDED(v)=1 \
+                         CEF_API_REMOVED(v)=1 \
+                         CEF_API_RANGE(a,r)=1
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

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,111 @@
+# 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 = 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",
+        ] + deps,
+        linkopts = [
+            "$(location @cef//:cef_lib)",
+            "$(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 = [
+            "@cef//:cef_lib",
+            ":{}".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,192 @@
+# 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.
+#
+
+DLLS = [
+    "chrome_elf.dll",
+    "d3dcompiler_47.dll",
+    "libcef.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). Lists should be kept in sync with
+# targets from Chromium's //build/config/win/BUILD.gn file.
+DELAYLOAD_DLLS = [
+    # Required to support CefScopedLibraryLoader.
+    "libcef.dll"
+
+    # "delayloads" target.
+    "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",
+
+    # "delayloads_not_for_child_dll" target.
+    "crypt32.dll",
+    "dbghelp.dll",
+    "dhcpcsvc.dll",
+    "dwrite.dll",
+    "iphlpapi.dll",
+    "oleaut32.dll",
+    "secur32.dll",
+    "userenv.dll",
+    "winhttp.dll",
+    "winmm.dll",
+    "winspool.drv",
+    "wintrust.dll",
+    "ws2_32.dll",
+]
+
+# Standard link libraries.
+STANDARD_LIBS = [
+    "comctl32.lib",
+    "crypt32.lib",
+    "delayimp.lib",
+    "gdi32.lib",
+    "rpcrt4.lib",
+    "shlwapi.lib",
+    "user32.lib",
+    "wintrust.lib",
+    "ws2_32.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",
+]
+
+COMMON_DEFINES_DEBUG = [
+]
+
+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_api_versions.json

@@ -0,0 +1,78 @@
+{
+  "hashes": {
+    "13300": {
+      "comment": "Added February 21, 2025.",
+      "linux": "2508f3f0b0e5dfa191036fa6c04f8dcfa18c94b9",
+      "mac": "80c0b59ba9dd783aa71fae0aa5f7dad64620e8c9",
+      "windows": "45d39c3669ba75467e3e609f626c31506c0eae22"
+    },
+    "13301": {
+      "comment": "Added February 21, 2025.",
+      "linux": "aa073dd1c586812503ca293c718358460d8c2dd6",
+      "mac": "fda40a5df44628cac50a589ff979c0746011591e",
+      "windows": "7109702038d51512d35dd2ed77231f9100e38214"
+    },
+    "13302": {
+      "comment": "Added February 21, 2025.",
+      "linux": "d5597ebfa30081953425e897209a8387b9584205",
+      "mac": "4aa24470ba3a4bd9c06bc0e4a201b896394a86b5",
+      "windows": "18799961f4461a9cbae2aed89ac04b73ab7c37f3"
+    },
+    "13303": {
+      "comment": "Added February 21, 2025.",
+      "linux": "f3a696ee30ce1e00490a58df017393c126c89709",
+      "mac": "f2cdce2b9a4b635c28b5b92c42c35625a937380c",
+      "windows": "20016fd6a9b87ef4c539cd1f42bf1ca09b6903ca"
+    },
+    "13304": {
+      "comment": "Added February 21, 2025.",
+      "linux": "f1ababb4ff51ecbf77c481cee3721ef0eca9c8ca",
+      "mac": "98964c37b8917d83da4b173e22905503d38ad08f",
+      "windows": "19c014af0082aa901398e006381b6980e4f806e9"
+    },
+    "13400": {
+      "comment": "Added February 21, 2025.",
+      "linux": "ea2106b5bc012c25d735521e0c7fb719d433ea4a",
+      "mac": "ba5ab71db4f9447f19eb7b1943024981c88064dd",
+      "windows": "6ab74b90e88b7397aab9911baac5484f12466eef"
+    },
+    "13401": {
+      "comment": "Added March 10, 2025.",
+      "linux": "b14bee2c0fd250da67faea421f620b58e5dea9a2",
+      "mac": "b54732b528bc2669481ec0cf17c7b97b033720b9",
+      "windows": "751255204f006b8b883a8baf552a2da792f8aa44"
+    },
+    "13500": {
+      "comment": "Added March 12, 2025.",
+      "linux": "5b7c2284ed2542cf6212981d62ca9122fb2a4e88",
+      "mac": "9862177631e8059a497d6086058168dd47477ab7",
+      "windows": "3e78b6fe5fd31d69049499450849ada17a720a53"
+    },
+    "13600": {
+      "comment": "Added April 07, 2025.",
+      "linux": "eb353ba7b8b9bcbef890217971cd8ec41efeaa75",
+      "mac": "22c77d1f2305de8a6147f14e52f074b4a4e5222c",
+      "windows": "a8832519b4eb058567d68b65be1e1c9e80aae566"
+    },
+    "13601": {
+      "comment": "Added April 22, 2025.",
+      "linux": "40b224f295a20694241c5db49721bc90a3796f30",
+      "mac": "ff885fe921f9eae1a5ce6a71b30b0c37b306bf56",
+      "windows": "116a4153047ee1ee67f17fc938f084ee72b24e54"
+    },
+    "13700": {
+      "comment": "Added May 07, 2025.",
+      "linux": "e5ac12b1bd88b9ece6ceaa57848aaba61ab85242",
+      "mac": "9e84009c92c25aa80935727b5e4526b23439a575",
+      "windows": "65c7157dd3e8eba9bcc38db2bd7f26508c717f3e"
+    },
+    "13800": {
+      "comment": "Added June 02, 2025.",
+      "linux": "72c83a1455706c0f964505a6edcbf00c4a00575d",
+      "mac": "09110c1f3bbe0e8a8c26ddf6df3388d73a6593d1",
+      "windows": "1cde3ec27f93747ba42c0f2aa00467a5a16adfd4"
+    }
+  },
+  "last": "13800",
+  "min": "13300"
+}

cef_paths.gypi

@@ -1,887 +0,0 @@
-# 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.
-#
-# ---------------------------------------------------------------------------
-#
-# 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=3b28f3236c16d2b776a44674ae3bae0a070e9f27$
-#
-
-{
-  'variables': {
-    'autogen_cpp_includes': [
-      'include/cef_accessibility_handler.h',
-      'include/cef_app.h',
-      'include/cef_audio_handler.h',
-      'include/cef_auth_callback.h',
-      'include/cef_browser.h',
-      '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',
-      'include/cef_crash_util.h',
-      'include/cef_devtools_message_observer.h',
-      'include/cef_dialog_handler.h',
-      'include/cef_display_handler.h',
-      'include/cef_dom.h',
-      'include/cef_download_handler.h',
-      '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',
-      'include/cef_frame.h',
-      'include/cef_frame_handler.h',
-      'include/cef_i18n_util.h',
-      'include/cef_image.h',
-      'include/cef_jsdialog_handler.h',
-      'include/cef_keyboard_handler.h',
-      'include/cef_life_span_handler.h',
-      'include/cef_load_handler.h',
-      'include/cef_media_router.h',
-      'include/cef_menu_model.h',
-      'include/cef_menu_model_delegate.h',
-      'include/cef_navigation_entry.h',
-      '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',
-      'include/cef_process_util.h',
-      'include/cef_registration.h',
-      'include/cef_render_handler.h',
-      'include/cef_render_process_handler.h',
-      'include/cef_request.h',
-      'include/cef_request_context.h',
-      'include/cef_request_context_handler.h',
-      'include/cef_request_handler.h',
-      'include/cef_resource_bundle.h',
-      'include/cef_resource_bundle_handler.h',
-      'include/cef_resource_handler.h',
-      'include/cef_resource_request_handler.h',
-      'include/cef_response.h',
-      '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_thread.h',
-      'include/cef_trace.h',
-      'include/cef_unresponsive_process_callback.h',
-      'include/cef_urlrequest.h',
-      'include/cef_v8.h',
-      'include/cef_values.h',
-      'include/cef_waitable_event.h',
-      'include/cef_x509_certificate.h',
-      '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',
-      'include/views/cef_browser_view_delegate.h',
-      'include/views/cef_button.h',
-      'include/views/cef_button_delegate.h',
-      'include/views/cef_display.h',
-      'include/views/cef_fill_layout.h',
-      'include/views/cef_label_button.h',
-      'include/views/cef_layout.h',
-      'include/views/cef_menu_button.h',
-      'include/views/cef_menu_button_delegate.h',
-      'include/views/cef_overlay_controller.h',
-      'include/views/cef_panel.h',
-      'include/views/cef_panel_delegate.h',
-      'include/views/cef_scroll_view.h',
-      'include/views/cef_textfield.h',
-      'include/views/cef_textfield_delegate.h',
-      'include/views/cef_view.h',
-      'include/views/cef_view_delegate.h',
-      'include/views/cef_window.h',
-      'include/views/cef_window_delegate.h',
-    ],
-    'autogen_capi_includes': [
-      'include/capi/cef_accessibility_handler_capi.h',
-      'include/capi/cef_app_capi.h',
-      'include/capi/cef_audio_handler_capi.h',
-      'include/capi/cef_auth_callback_capi.h',
-      'include/capi/cef_browser_capi.h',
-      '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',
-      'include/capi/cef_crash_util_capi.h',
-      'include/capi/cef_devtools_message_observer_capi.h',
-      'include/capi/cef_dialog_handler_capi.h',
-      'include/capi/cef_display_handler_capi.h',
-      'include/capi/cef_dom_capi.h',
-      'include/capi/cef_download_handler_capi.h',
-      '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',
-      'include/capi/cef_frame_capi.h',
-      'include/capi/cef_frame_handler_capi.h',
-      'include/capi/cef_i18n_util_capi.h',
-      'include/capi/cef_image_capi.h',
-      'include/capi/cef_jsdialog_handler_capi.h',
-      'include/capi/cef_keyboard_handler_capi.h',
-      'include/capi/cef_life_span_handler_capi.h',
-      'include/capi/cef_load_handler_capi.h',
-      'include/capi/cef_media_router_capi.h',
-      'include/capi/cef_menu_model_capi.h',
-      'include/capi/cef_menu_model_delegate_capi.h',
-      'include/capi/cef_navigation_entry_capi.h',
-      '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',
-      'include/capi/cef_process_util_capi.h',
-      'include/capi/cef_registration_capi.h',
-      'include/capi/cef_render_handler_capi.h',
-      'include/capi/cef_render_process_handler_capi.h',
-      'include/capi/cef_request_capi.h',
-      'include/capi/cef_request_context_capi.h',
-      'include/capi/cef_request_context_handler_capi.h',
-      'include/capi/cef_request_handler_capi.h',
-      'include/capi/cef_resource_bundle_capi.h',
-      'include/capi/cef_resource_bundle_handler_capi.h',
-      'include/capi/cef_resource_handler_capi.h',
-      'include/capi/cef_resource_request_handler_capi.h',
-      'include/capi/cef_response_capi.h',
-      '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_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',
-      'include/capi/cef_waitable_event_capi.h',
-      'include/capi/cef_x509_certificate_capi.h',
-      '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',
-      'include/capi/views/cef_browser_view_delegate_capi.h',
-      'include/capi/views/cef_button_capi.h',
-      'include/capi/views/cef_button_delegate_capi.h',
-      'include/capi/views/cef_display_capi.h',
-      'include/capi/views/cef_fill_layout_capi.h',
-      'include/capi/views/cef_label_button_capi.h',
-      'include/capi/views/cef_layout_capi.h',
-      'include/capi/views/cef_menu_button_capi.h',
-      'include/capi/views/cef_menu_button_delegate_capi.h',
-      'include/capi/views/cef_overlay_controller_capi.h',
-      'include/capi/views/cef_panel_capi.h',
-      'include/capi/views/cef_panel_delegate_capi.h',
-      'include/capi/views/cef_scroll_view_capi.h',
-      'include/capi/views/cef_textfield_capi.h',
-      'include/capi/views/cef_textfield_delegate_capi.h',
-      'include/capi/views/cef_view_capi.h',
-      'include/capi/views/cef_view_delegate_capi.h',
-      'include/capi/views/cef_window_capi.h',
-      'include/capi/views/cef_window_delegate_capi.h',
-    ],
-    'autogen_library_side': [
-      'libcef_dll/ctocpp/accessibility_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/accessibility_handler_ctocpp.h',
-      'libcef_dll/ctocpp/app_ctocpp.cc',
-      'libcef_dll/ctocpp/app_ctocpp.h',
-      'libcef_dll/ctocpp/audio_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/audio_handler_ctocpp.h',
-      'libcef_dll/cpptoc/auth_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/auth_callback_cpptoc.h',
-      'libcef_dll/cpptoc/before_download_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/before_download_callback_cpptoc.h',
-      'libcef_dll/cpptoc/binary_value_cpptoc.cc',
-      'libcef_dll/cpptoc/binary_value_cpptoc.h',
-      'libcef_dll/cpptoc/views/box_layout_cpptoc.cc',
-      'libcef_dll/cpptoc/views/box_layout_cpptoc.h',
-      'libcef_dll/cpptoc/browser_cpptoc.cc',
-      'libcef_dll/cpptoc/browser_cpptoc.h',
-      'libcef_dll/cpptoc/browser_host_cpptoc.cc',
-      'libcef_dll/cpptoc/browser_host_cpptoc.h',
-      'libcef_dll/ctocpp/browser_process_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/browser_process_handler_ctocpp.h',
-      'libcef_dll/cpptoc/views/browser_view_cpptoc.cc',
-      'libcef_dll/cpptoc/views/browser_view_cpptoc.h',
-      'libcef_dll/ctocpp/views/browser_view_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/views/browser_view_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/views/button_cpptoc.cc',
-      'libcef_dll/cpptoc/views/button_cpptoc.h',
-      'libcef_dll/ctocpp/views/button_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/views/button_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/callback_cpptoc.cc',
-      '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',
-      'libcef_dll/ctocpp/completion_callback_ctocpp.h',
-      'libcef_dll/ctocpp/context_menu_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/context_menu_handler_ctocpp.h',
-      'libcef_dll/cpptoc/context_menu_params_cpptoc.cc',
-      'libcef_dll/cpptoc/context_menu_params_cpptoc.h',
-      'libcef_dll/ctocpp/cookie_access_filter_ctocpp.cc',
-      'libcef_dll/ctocpp/cookie_access_filter_ctocpp.h',
-      'libcef_dll/cpptoc/cookie_manager_cpptoc.cc',
-      'libcef_dll/cpptoc/cookie_manager_cpptoc.h',
-      'libcef_dll/ctocpp/cookie_visitor_ctocpp.cc',
-      'libcef_dll/ctocpp/cookie_visitor_ctocpp.h',
-      'libcef_dll/cpptoc/domdocument_cpptoc.cc',
-      'libcef_dll/cpptoc/domdocument_cpptoc.h',
-      'libcef_dll/cpptoc/domnode_cpptoc.cc',
-      'libcef_dll/cpptoc/domnode_cpptoc.h',
-      'libcef_dll/ctocpp/domvisitor_ctocpp.cc',
-      'libcef_dll/ctocpp/domvisitor_ctocpp.h',
-      'libcef_dll/ctocpp/delete_cookies_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/delete_cookies_callback_ctocpp.h',
-      'libcef_dll/ctocpp/dev_tools_message_observer_ctocpp.cc',
-      'libcef_dll/ctocpp/dev_tools_message_observer_ctocpp.h',
-      'libcef_dll/ctocpp/dialog_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/dialog_handler_ctocpp.h',
-      'libcef_dll/cpptoc/dictionary_value_cpptoc.cc',
-      'libcef_dll/cpptoc/dictionary_value_cpptoc.h',
-      'libcef_dll/cpptoc/views/display_cpptoc.cc',
-      'libcef_dll/cpptoc/views/display_cpptoc.h',
-      'libcef_dll/ctocpp/display_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/display_handler_ctocpp.h',
-      'libcef_dll/ctocpp/download_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/download_handler_ctocpp.h',
-      'libcef_dll/ctocpp/download_image_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/download_image_callback_ctocpp.h',
-      'libcef_dll/cpptoc/download_item_cpptoc.cc',
-      'libcef_dll/cpptoc/download_item_cpptoc.h',
-      'libcef_dll/cpptoc/download_item_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/download_item_callback_cpptoc.h',
-      'libcef_dll/cpptoc/drag_data_cpptoc.cc',
-      'libcef_dll/cpptoc/drag_data_cpptoc.h',
-      'libcef_dll/ctocpp/drag_handler_ctocpp.cc',
-      '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',
-      'libcef_dll/cpptoc/views/fill_layout_cpptoc.h',
-      'libcef_dll/ctocpp/find_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/find_handler_ctocpp.h',
-      'libcef_dll/ctocpp/focus_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/focus_handler_ctocpp.h',
-      'libcef_dll/cpptoc/frame_cpptoc.cc',
-      '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',
-      'libcef_dll/cpptoc/jsdialog_callback_cpptoc.h',
-      'libcef_dll/ctocpp/jsdialog_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/jsdialog_handler_ctocpp.h',
-      'libcef_dll/ctocpp/keyboard_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/keyboard_handler_ctocpp.h',
-      'libcef_dll/cpptoc/views/label_button_cpptoc.cc',
-      'libcef_dll/cpptoc/views/label_button_cpptoc.h',
-      'libcef_dll/cpptoc/views/layout_cpptoc.cc',
-      'libcef_dll/cpptoc/views/layout_cpptoc.h',
-      'libcef_dll/ctocpp/life_span_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/life_span_handler_ctocpp.h',
-      'libcef_dll/cpptoc/list_value_cpptoc.cc',
-      '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',
-      'libcef_dll/cpptoc/media_route_cpptoc.h',
-      'libcef_dll/ctocpp/media_route_create_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/media_route_create_callback_ctocpp.h',
-      'libcef_dll/cpptoc/media_router_cpptoc.cc',
-      'libcef_dll/cpptoc/media_router_cpptoc.h',
-      'libcef_dll/cpptoc/media_sink_cpptoc.cc',
-      'libcef_dll/cpptoc/media_sink_cpptoc.h',
-      'libcef_dll/ctocpp/media_sink_device_info_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/media_sink_device_info_callback_ctocpp.h',
-      'libcef_dll/cpptoc/media_source_cpptoc.cc',
-      'libcef_dll/cpptoc/media_source_cpptoc.h',
-      'libcef_dll/cpptoc/views/menu_button_cpptoc.cc',
-      'libcef_dll/cpptoc/views/menu_button_cpptoc.h',
-      'libcef_dll/ctocpp/views/menu_button_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/views/menu_button_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/views/menu_button_pressed_lock_cpptoc.cc',
-      'libcef_dll/cpptoc/views/menu_button_pressed_lock_cpptoc.h',
-      'libcef_dll/cpptoc/menu_model_cpptoc.cc',
-      'libcef_dll/cpptoc/menu_model_cpptoc.h',
-      'libcef_dll/ctocpp/menu_model_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/menu_model_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/navigation_entry_cpptoc.cc',
-      'libcef_dll/cpptoc/navigation_entry_cpptoc.h',
-      'libcef_dll/ctocpp/navigation_entry_visitor_ctocpp.cc',
-      'libcef_dll/ctocpp/navigation_entry_visitor_ctocpp.h',
-      'libcef_dll/cpptoc/views/overlay_controller_cpptoc.cc',
-      'libcef_dll/cpptoc/views/overlay_controller_cpptoc.h',
-      'libcef_dll/cpptoc/views/panel_cpptoc.cc',
-      'libcef_dll/cpptoc/views/panel_cpptoc.h',
-      'libcef_dll/ctocpp/views/panel_delegate_ctocpp.cc',
-      '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',
-      'libcef_dll/ctocpp/print_handler_ctocpp.h',
-      'libcef_dll/cpptoc/print_job_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/print_job_callback_cpptoc.h',
-      'libcef_dll/cpptoc/print_settings_cpptoc.cc',
-      'libcef_dll/cpptoc/print_settings_cpptoc.h',
-      'libcef_dll/cpptoc/process_message_cpptoc.cc',
-      'libcef_dll/cpptoc/process_message_cpptoc.h',
-      'libcef_dll/ctocpp/read_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/read_handler_ctocpp.h',
-      'libcef_dll/cpptoc/registration_cpptoc.cc',
-      'libcef_dll/cpptoc/registration_cpptoc.h',
-      'libcef_dll/ctocpp/render_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/render_handler_ctocpp.h',
-      'libcef_dll/ctocpp/render_process_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/render_process_handler_ctocpp.h',
-      'libcef_dll/cpptoc/request_cpptoc.cc',
-      'libcef_dll/cpptoc/request_cpptoc.h',
-      'libcef_dll/cpptoc/request_context_cpptoc.cc',
-      'libcef_dll/cpptoc/request_context_cpptoc.h',
-      'libcef_dll/ctocpp/request_context_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/request_context_handler_ctocpp.h',
-      'libcef_dll/ctocpp/request_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/request_handler_ctocpp.h',
-      'libcef_dll/ctocpp/resolve_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/resolve_callback_ctocpp.h',
-      'libcef_dll/cpptoc/resource_bundle_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_bundle_cpptoc.h',
-      'libcef_dll/ctocpp/resource_bundle_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_bundle_handler_ctocpp.h',
-      'libcef_dll/ctocpp/resource_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_handler_ctocpp.h',
-      'libcef_dll/cpptoc/resource_read_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_read_callback_cpptoc.h',
-      'libcef_dll/ctocpp/resource_request_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_request_handler_ctocpp.h',
-      'libcef_dll/cpptoc/resource_skip_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_skip_callback_cpptoc.h',
-      'libcef_dll/cpptoc/response_cpptoc.cc',
-      'libcef_dll/cpptoc/response_cpptoc.h',
-      'libcef_dll/ctocpp/response_filter_ctocpp.cc',
-      'libcef_dll/ctocpp/response_filter_ctocpp.h',
-      'libcef_dll/cpptoc/run_context_menu_callback_cpptoc.cc',
-      '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',
-      'libcef_dll/cpptoc/sslstatus_cpptoc.h',
-      'libcef_dll/ctocpp/scheme_handler_factory_ctocpp.cc',
-      'libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h',
-      'libcef_dll/cpptoc/scheme_registrar_cpptoc.cc',
-      'libcef_dll/cpptoc/scheme_registrar_cpptoc.h',
-      'libcef_dll/cpptoc/views/scroll_view_cpptoc.cc',
-      'libcef_dll/cpptoc/views/scroll_view_cpptoc.h',
-      'libcef_dll/cpptoc/select_client_certificate_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/select_client_certificate_callback_cpptoc.h',
-      'libcef_dll/cpptoc/server_cpptoc.cc',
-      'libcef_dll/cpptoc/server_cpptoc.h',
-      'libcef_dll/ctocpp/server_handler_ctocpp.cc',
-      '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',
-      'libcef_dll/cpptoc/stream_writer_cpptoc.h',
-      'libcef_dll/ctocpp/string_visitor_ctocpp.cc',
-      'libcef_dll/ctocpp/string_visitor_ctocpp.h',
-      'libcef_dll/ctocpp/task_ctocpp.cc',
-      'libcef_dll/ctocpp/task_ctocpp.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',
-      'libcef_dll/ctocpp/views/textfield_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/thread_cpptoc.cc',
-      'libcef_dll/cpptoc/thread_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_child_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_child_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_scoped_client_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_scoped_client_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_scoped_client_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_scoped_client_child_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_child_cpptoc.h',
-      'libcef_dll/cpptoc/urlrequest_cpptoc.cc',
-      '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',
-      'libcef_dll/ctocpp/v8array_buffer_release_callback_ctocpp.h',
-      'libcef_dll/cpptoc/v8context_cpptoc.cc',
-      'libcef_dll/cpptoc/v8context_cpptoc.h',
-      'libcef_dll/cpptoc/v8exception_cpptoc.cc',
-      'libcef_dll/cpptoc/v8exception_cpptoc.h',
-      'libcef_dll/ctocpp/v8handler_ctocpp.cc',
-      'libcef_dll/ctocpp/v8handler_ctocpp.h',
-      'libcef_dll/ctocpp/v8interceptor_ctocpp.cc',
-      'libcef_dll/ctocpp/v8interceptor_ctocpp.h',
-      'libcef_dll/cpptoc/v8stack_frame_cpptoc.cc',
-      'libcef_dll/cpptoc/v8stack_frame_cpptoc.h',
-      'libcef_dll/cpptoc/v8stack_trace_cpptoc.cc',
-      'libcef_dll/cpptoc/v8stack_trace_cpptoc.h',
-      'libcef_dll/cpptoc/v8value_cpptoc.cc',
-      'libcef_dll/cpptoc/v8value_cpptoc.h',
-      'libcef_dll/cpptoc/value_cpptoc.cc',
-      'libcef_dll/cpptoc/value_cpptoc.h',
-      'libcef_dll/cpptoc/views/view_cpptoc.cc',
-      'libcef_dll/cpptoc/views/view_cpptoc.h',
-      'libcef_dll/ctocpp/views/view_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/views/view_delegate_ctocpp.h',
-      'libcef_dll/cpptoc/waitable_event_cpptoc.cc',
-      'libcef_dll/cpptoc/waitable_event_cpptoc.h',
-      'libcef_dll/cpptoc/views/window_cpptoc.cc',
-      'libcef_dll/cpptoc/views/window_cpptoc.h',
-      'libcef_dll/ctocpp/views/window_delegate_ctocpp.cc',
-      'libcef_dll/ctocpp/views/window_delegate_ctocpp.h',
-      'libcef_dll/ctocpp/write_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/write_handler_ctocpp.h',
-      'libcef_dll/cpptoc/x509cert_principal_cpptoc.cc',
-      'libcef_dll/cpptoc/x509cert_principal_cpptoc.h',
-      'libcef_dll/cpptoc/x509certificate_cpptoc.cc',
-      'libcef_dll/cpptoc/x509certificate_cpptoc.h',
-      'libcef_dll/cpptoc/xml_reader_cpptoc.cc',
-      'libcef_dll/cpptoc/xml_reader_cpptoc.h',
-      'libcef_dll/cpptoc/zip_reader_cpptoc.cc',
-      'libcef_dll/cpptoc/zip_reader_cpptoc.h',
-    ],
-    'autogen_client_side': [
-      'libcef_dll/cpptoc/accessibility_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/accessibility_handler_cpptoc.h',
-      'libcef_dll/cpptoc/app_cpptoc.cc',
-      'libcef_dll/cpptoc/app_cpptoc.h',
-      'libcef_dll/cpptoc/audio_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/audio_handler_cpptoc.h',
-      'libcef_dll/ctocpp/auth_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/auth_callback_ctocpp.h',
-      'libcef_dll/ctocpp/before_download_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/before_download_callback_ctocpp.h',
-      'libcef_dll/ctocpp/binary_value_ctocpp.cc',
-      'libcef_dll/ctocpp/binary_value_ctocpp.h',
-      'libcef_dll/ctocpp/views/box_layout_ctocpp.cc',
-      'libcef_dll/ctocpp/views/box_layout_ctocpp.h',
-      'libcef_dll/ctocpp/browser_ctocpp.cc',
-      'libcef_dll/ctocpp/browser_ctocpp.h',
-      'libcef_dll/ctocpp/browser_host_ctocpp.cc',
-      'libcef_dll/ctocpp/browser_host_ctocpp.h',
-      'libcef_dll/cpptoc/browser_process_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/browser_process_handler_cpptoc.h',
-      'libcef_dll/ctocpp/views/browser_view_ctocpp.cc',
-      'libcef_dll/ctocpp/views/browser_view_ctocpp.h',
-      'libcef_dll/cpptoc/views/browser_view_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/views/browser_view_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/views/button_ctocpp.cc',
-      'libcef_dll/ctocpp/views/button_ctocpp.h',
-      'libcef_dll/cpptoc/views/button_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/views/button_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/callback_ctocpp.cc',
-      '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',
-      'libcef_dll/cpptoc/completion_callback_cpptoc.h',
-      'libcef_dll/cpptoc/context_menu_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/context_menu_handler_cpptoc.h',
-      'libcef_dll/ctocpp/context_menu_params_ctocpp.cc',
-      'libcef_dll/ctocpp/context_menu_params_ctocpp.h',
-      'libcef_dll/cpptoc/cookie_access_filter_cpptoc.cc',
-      'libcef_dll/cpptoc/cookie_access_filter_cpptoc.h',
-      'libcef_dll/ctocpp/cookie_manager_ctocpp.cc',
-      'libcef_dll/ctocpp/cookie_manager_ctocpp.h',
-      'libcef_dll/cpptoc/cookie_visitor_cpptoc.cc',
-      'libcef_dll/cpptoc/cookie_visitor_cpptoc.h',
-      'libcef_dll/ctocpp/domdocument_ctocpp.cc',
-      'libcef_dll/ctocpp/domdocument_ctocpp.h',
-      'libcef_dll/ctocpp/domnode_ctocpp.cc',
-      'libcef_dll/ctocpp/domnode_ctocpp.h',
-      'libcef_dll/cpptoc/domvisitor_cpptoc.cc',
-      'libcef_dll/cpptoc/domvisitor_cpptoc.h',
-      'libcef_dll/cpptoc/delete_cookies_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h',
-      'libcef_dll/cpptoc/dev_tools_message_observer_cpptoc.cc',
-      'libcef_dll/cpptoc/dev_tools_message_observer_cpptoc.h',
-      'libcef_dll/cpptoc/dialog_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/dialog_handler_cpptoc.h',
-      'libcef_dll/ctocpp/dictionary_value_ctocpp.cc',
-      'libcef_dll/ctocpp/dictionary_value_ctocpp.h',
-      'libcef_dll/ctocpp/views/display_ctocpp.cc',
-      'libcef_dll/ctocpp/views/display_ctocpp.h',
-      'libcef_dll/cpptoc/display_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/display_handler_cpptoc.h',
-      'libcef_dll/cpptoc/download_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/download_handler_cpptoc.h',
-      'libcef_dll/cpptoc/download_image_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/download_image_callback_cpptoc.h',
-      'libcef_dll/ctocpp/download_item_ctocpp.cc',
-      'libcef_dll/ctocpp/download_item_ctocpp.h',
-      'libcef_dll/ctocpp/download_item_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/download_item_callback_ctocpp.h',
-      'libcef_dll/ctocpp/drag_data_ctocpp.cc',
-      'libcef_dll/ctocpp/drag_data_ctocpp.h',
-      'libcef_dll/cpptoc/drag_handler_cpptoc.cc',
-      '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',
-      'libcef_dll/ctocpp/views/fill_layout_ctocpp.h',
-      'libcef_dll/cpptoc/find_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/find_handler_cpptoc.h',
-      'libcef_dll/cpptoc/focus_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/focus_handler_cpptoc.h',
-      'libcef_dll/ctocpp/frame_ctocpp.cc',
-      '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',
-      'libcef_dll/ctocpp/jsdialog_callback_ctocpp.h',
-      'libcef_dll/cpptoc/jsdialog_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/jsdialog_handler_cpptoc.h',
-      'libcef_dll/cpptoc/keyboard_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/keyboard_handler_cpptoc.h',
-      'libcef_dll/ctocpp/views/label_button_ctocpp.cc',
-      'libcef_dll/ctocpp/views/label_button_ctocpp.h',
-      'libcef_dll/ctocpp/views/layout_ctocpp.cc',
-      'libcef_dll/ctocpp/views/layout_ctocpp.h',
-      'libcef_dll/cpptoc/life_span_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/life_span_handler_cpptoc.h',
-      'libcef_dll/ctocpp/list_value_ctocpp.cc',
-      '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',
-      'libcef_dll/ctocpp/media_route_ctocpp.h',
-      'libcef_dll/cpptoc/media_route_create_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/media_route_create_callback_cpptoc.h',
-      'libcef_dll/ctocpp/media_router_ctocpp.cc',
-      'libcef_dll/ctocpp/media_router_ctocpp.h',
-      'libcef_dll/ctocpp/media_sink_ctocpp.cc',
-      'libcef_dll/ctocpp/media_sink_ctocpp.h',
-      'libcef_dll/cpptoc/media_sink_device_info_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/media_sink_device_info_callback_cpptoc.h',
-      'libcef_dll/ctocpp/media_source_ctocpp.cc',
-      'libcef_dll/ctocpp/media_source_ctocpp.h',
-      'libcef_dll/ctocpp/views/menu_button_ctocpp.cc',
-      'libcef_dll/ctocpp/views/menu_button_ctocpp.h',
-      'libcef_dll/cpptoc/views/menu_button_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/views/menu_button_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/views/menu_button_pressed_lock_ctocpp.cc',
-      'libcef_dll/ctocpp/views/menu_button_pressed_lock_ctocpp.h',
-      'libcef_dll/ctocpp/menu_model_ctocpp.cc',
-      'libcef_dll/ctocpp/menu_model_ctocpp.h',
-      'libcef_dll/cpptoc/menu_model_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/menu_model_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/navigation_entry_ctocpp.cc',
-      'libcef_dll/ctocpp/navigation_entry_ctocpp.h',
-      'libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.cc',
-      'libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.h',
-      'libcef_dll/ctocpp/views/overlay_controller_ctocpp.cc',
-      'libcef_dll/ctocpp/views/overlay_controller_ctocpp.h',
-      'libcef_dll/ctocpp/views/panel_ctocpp.cc',
-      'libcef_dll/ctocpp/views/panel_ctocpp.h',
-      'libcef_dll/cpptoc/views/panel_delegate_cpptoc.cc',
-      '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',
-      'libcef_dll/cpptoc/print_handler_cpptoc.h',
-      'libcef_dll/ctocpp/print_job_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/print_job_callback_ctocpp.h',
-      'libcef_dll/ctocpp/print_settings_ctocpp.cc',
-      'libcef_dll/ctocpp/print_settings_ctocpp.h',
-      'libcef_dll/ctocpp/process_message_ctocpp.cc',
-      'libcef_dll/ctocpp/process_message_ctocpp.h',
-      'libcef_dll/cpptoc/read_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/read_handler_cpptoc.h',
-      'libcef_dll/ctocpp/registration_ctocpp.cc',
-      'libcef_dll/ctocpp/registration_ctocpp.h',
-      'libcef_dll/cpptoc/render_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/render_handler_cpptoc.h',
-      'libcef_dll/cpptoc/render_process_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/render_process_handler_cpptoc.h',
-      'libcef_dll/ctocpp/request_ctocpp.cc',
-      'libcef_dll/ctocpp/request_ctocpp.h',
-      'libcef_dll/ctocpp/request_context_ctocpp.cc',
-      'libcef_dll/ctocpp/request_context_ctocpp.h',
-      'libcef_dll/cpptoc/request_context_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/request_context_handler_cpptoc.h',
-      'libcef_dll/cpptoc/request_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/request_handler_cpptoc.h',
-      'libcef_dll/cpptoc/resolve_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/resolve_callback_cpptoc.h',
-      'libcef_dll/ctocpp/resource_bundle_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_bundle_ctocpp.h',
-      'libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h',
-      'libcef_dll/cpptoc/resource_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_handler_cpptoc.h',
-      'libcef_dll/ctocpp/resource_read_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_read_callback_ctocpp.h',
-      'libcef_dll/cpptoc/resource_request_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/resource_request_handler_cpptoc.h',
-      'libcef_dll/ctocpp/resource_skip_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/resource_skip_callback_ctocpp.h',
-      'libcef_dll/ctocpp/response_ctocpp.cc',
-      'libcef_dll/ctocpp/response_ctocpp.h',
-      'libcef_dll/cpptoc/response_filter_cpptoc.cc',
-      'libcef_dll/cpptoc/response_filter_cpptoc.h',
-      'libcef_dll/ctocpp/run_context_menu_callback_ctocpp.cc',
-      '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',
-      'libcef_dll/ctocpp/sslstatus_ctocpp.h',
-      'libcef_dll/cpptoc/scheme_handler_factory_cpptoc.cc',
-      'libcef_dll/cpptoc/scheme_handler_factory_cpptoc.h',
-      'libcef_dll/ctocpp/scheme_registrar_ctocpp.cc',
-      'libcef_dll/ctocpp/scheme_registrar_ctocpp.h',
-      'libcef_dll/ctocpp/views/scroll_view_ctocpp.cc',
-      'libcef_dll/ctocpp/views/scroll_view_ctocpp.h',
-      'libcef_dll/ctocpp/select_client_certificate_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/select_client_certificate_callback_ctocpp.h',
-      'libcef_dll/ctocpp/server_ctocpp.cc',
-      'libcef_dll/ctocpp/server_ctocpp.h',
-      'libcef_dll/cpptoc/server_handler_cpptoc.cc',
-      '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',
-      'libcef_dll/ctocpp/stream_writer_ctocpp.h',
-      'libcef_dll/cpptoc/string_visitor_cpptoc.cc',
-      'libcef_dll/cpptoc/string_visitor_cpptoc.h',
-      'libcef_dll/cpptoc/task_cpptoc.cc',
-      'libcef_dll/cpptoc/task_cpptoc.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',
-      'libcef_dll/cpptoc/views/textfield_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/thread_ctocpp.cc',
-      'libcef_dll/ctocpp/thread_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_child_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_child_ctocpp.h',
-      'libcef_dll/ctocpp/urlrequest_ctocpp.cc',
-      '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',
-      'libcef_dll/cpptoc/v8array_buffer_release_callback_cpptoc.h',
-      'libcef_dll/ctocpp/v8context_ctocpp.cc',
-      'libcef_dll/ctocpp/v8context_ctocpp.h',
-      'libcef_dll/ctocpp/v8exception_ctocpp.cc',
-      'libcef_dll/ctocpp/v8exception_ctocpp.h',
-      'libcef_dll/cpptoc/v8handler_cpptoc.cc',
-      'libcef_dll/cpptoc/v8handler_cpptoc.h',
-      'libcef_dll/cpptoc/v8interceptor_cpptoc.cc',
-      'libcef_dll/cpptoc/v8interceptor_cpptoc.h',
-      'libcef_dll/ctocpp/v8stack_frame_ctocpp.cc',
-      'libcef_dll/ctocpp/v8stack_frame_ctocpp.h',
-      'libcef_dll/ctocpp/v8stack_trace_ctocpp.cc',
-      'libcef_dll/ctocpp/v8stack_trace_ctocpp.h',
-      'libcef_dll/ctocpp/v8value_ctocpp.cc',
-      'libcef_dll/ctocpp/v8value_ctocpp.h',
-      'libcef_dll/ctocpp/value_ctocpp.cc',
-      'libcef_dll/ctocpp/value_ctocpp.h',
-      'libcef_dll/ctocpp/views/view_ctocpp.cc',
-      'libcef_dll/ctocpp/views/view_ctocpp.h',
-      'libcef_dll/cpptoc/views/view_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/views/view_delegate_cpptoc.h',
-      'libcef_dll/ctocpp/waitable_event_ctocpp.cc',
-      'libcef_dll/ctocpp/waitable_event_ctocpp.h',
-      'libcef_dll/ctocpp/views/window_ctocpp.cc',
-      'libcef_dll/ctocpp/views/window_ctocpp.h',
-      'libcef_dll/cpptoc/views/window_delegate_cpptoc.cc',
-      'libcef_dll/cpptoc/views/window_delegate_cpptoc.h',
-      'libcef_dll/cpptoc/write_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/write_handler_cpptoc.h',
-      'libcef_dll/ctocpp/x509cert_principal_ctocpp.cc',
-      'libcef_dll/ctocpp/x509cert_principal_ctocpp.h',
-      'libcef_dll/ctocpp/x509certificate_ctocpp.cc',
-      'libcef_dll/ctocpp/x509certificate_ctocpp.h',
-      'libcef_dll/ctocpp/xml_reader_ctocpp.cc',
-      'libcef_dll/ctocpp/xml_reader_ctocpp.h',
-      'libcef_dll/ctocpp/zip_reader_ctocpp.cc',
-      'libcef_dll/ctocpp/zip_reader_ctocpp.h',
-    ],
-  },
-}

cef_paths2.gypi

@@ -16,6 +16,8 @@
       'include/base/cef_callback_list.h',
       'include/base/cef_cancelable_callback.h',
       'include/base/cef_compiler_specific.h',
+      'include/base/cef_dump_without_crashing.h',
+      'include/base/cef_immediate_crash.h',
       'include/base/cef_lock.h',
       'include/base/cef_logging.h',
       'include/base/cef_macros.h',
@@ -35,7 +37,6 @@
       'include/base/internal/cef_thread_checker_impl.h',
       'include/cef_api_hash.h',
       'include/cef_base.h',
-      'include/cef_version.h',
       'include/internal/cef_export.h',
       'include/internal/cef_ptr.h',
       'include/internal/cef_string_wrappers.h',
@@ -43,6 +44,9 @@
       'include/internal/cef_types_wrappers.h',
     ],
     'includes_common_capi': [
+      'include/cef_id_mappers.h',
+      'include/cef_version_info.h',
+      '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',
@@ -53,10 +57,11 @@
       'include/internal/cef_time.h',
       'include/internal/cef_trace_event_internal.h',
       'include/internal/cef_types.h',
+      'include/internal/cef_types_color.h',
       'include/internal/cef_types_content_settings.h',
       'include/internal/cef_types_geometry.h',
+      'include/internal/cef_types_osr.h',
       'include/internal/cef_types_runtime.h',
-      'include/internal/cef_types_color.h',
     ],
     'includes_capi': [
       'include/capi/cef_base_capi.h',
@@ -75,6 +80,11 @@
     'includes_wrapper_mac': [
       'include/wrapper/cef_library_loader.h',
     ],
+    'includes_wrapper_win': [
+      'include/wrapper/cef_certificate_util_win.h',
+      'include/wrapper/cef_library_loader.h',
+      'include/wrapper/cef_util_win.h',
+    ],
     'includes_win': [
       'include/cef_sandbox_win.h',
       'include/internal/cef_win.h',
@@ -123,6 +133,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',
@@ -160,9 +171,15 @@
       'libcef_dll/wrapper/libcef_dll_wrapper2.cc',
     ],
     'libcef_dll_wrapper_sources_mac': [
-      'libcef_dll/wrapper/cef_library_loader_mac.mm',
+      'libcef_dll/wrapper/cef_scoped_library_loader_mac.mm',
+      'libcef_dll/wrapper/cef_scoped_sandbox_context_mac.mm',
       'libcef_dll/wrapper/libcef_dll_dylib.cc',
     ],
+    'libcef_dll_wrapper_sources_win': [
+      'libcef_dll/wrapper/cef_certificate_util_win.cc',
+      'libcef_dll/wrapper/cef_scoped_library_loader_win.cc',
+      'libcef_dll/wrapper/cef_util_win.cc',
+    ],
     'shared_sources_browser': [
       'tests/shared/browser/client_app_browser.cc',
       'tests/shared/browser/client_app_browser.h',
@@ -242,6 +259,9 @@
       'tests/cefclient/browser/client_prefs.cc',
       'tests/cefclient/browser/client_prefs.h',
       'tests/cefclient/browser/client_types.h',
+      'tests/cefclient/browser/config_test.cc',
+      'tests/cefclient/browser/config_test.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',
@@ -275,6 +295,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',
@@ -282,6 +304,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',
@@ -314,6 +338,7 @@
     'cefclient_sources_resources': [
       'tests/cefclient/resources/binary_transfer.html',
       'tests/cefclient/resources/binding.html',
+      'tests/cefclient/resources/config.html',
       'tests/cefclient/resources/dialogs.html',
       'tests/cefclient/resources/draggable.html',
       'tests/cefclient/resources/hang.html',
@@ -329,6 +354,7 @@
       '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',
@@ -370,12 +396,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',
@@ -394,16 +422,18 @@
       '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/util_mac.h',
+      'tests/cefclient/browser/util_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',
@@ -435,15 +465,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',
@@ -456,7 +488,7 @@
       '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',
@@ -469,6 +501,7 @@
       'tests/ceftests/resources/net/data/ssl/certificates/root_ca_cert.pem',
     ],
     'ceftests_sources_common': [
+      'tests/ceftests/api_version_unittest.cc',
       'tests/ceftests/audio_output_unittest.cc',
       'tests/ceftests/browser_info_map_unittest.cc',
       'tests/ceftests/certificate_error_unittest.cc',
@@ -507,6 +540,7 @@
       'tests/ceftests/permission_prompt_unittest.cc',
       'tests/ceftests/preference_unittest.cc',
       'tests/ceftests/print_unittest.cc',
+      'tests/ceftests/print_to_pdf_unittest.cc',
       'tests/ceftests/process_message_unittest.cc',
       'tests/ceftests/request_context_unittest.cc',
       'tests/ceftests/request_handler_unittest.cc',
@@ -574,24 +608,32 @@
     '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',
@@ -647,10 +689,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

@@ -36,11 +36,7 @@ macro(PRINT_CEF_CONFIG)
 
   message(STATUS "CEF sandbox:                  ${USE_SANDBOX}")
 
-  set(_libraries ${CEF_STANDARD_LIBS})
-  if(OS_WINDOWS AND USE_SANDBOX)
-    list(APPEND _libraries ${CEF_SANDBOX_STANDARD_LIBS})
-  endif()
-  message(STATUS "Standard libraries:           ${_libraries}")
+  message(STATUS "Standard libraries:           ${CEF_STANDARD_LIBS}")
 
   message(STATUS "Compile defines:              ${CEF_COMPILER_DEFINES}")
   message(STATUS "Compile defines (Debug):      ${CEF_COMPILER_DEFINES_DEBUG}")
@@ -271,6 +267,17 @@ macro(ADD_WINDOWS_MANIFEST manifest_path target extension)
     )
 endmacro()
 
+# Set LPAC ACLs required for Windows sandbox support.
+# See https://github.com/chromiumembedded/cef/issues/3791#issuecomment-2664128961
+macro(SET_LPAC_ACLS target)
+  add_custom_command(
+    TARGET ${target}
+    POST_BUILD
+    COMMAND "icacls" "${CEF_TARGET_OUT_DIR}" "/grant" "*S-1-15-2-2:(OI)(CI)(RX)"
+    COMMENT "Setting LPAC ACLs..."
+    )
+endmacro()
+
 endif(OS_WINDOWS)
 
 

cmake/cef_variables.cmake.in

@@ -59,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
   )
@@ -69,6 +69,20 @@ list(APPEND CEF_COMPILER_DEFINES
 option(USE_SANDBOX "Enable or disable use of the sandbox." ON)
 
 
+# Optionally configure the CEF API version by adding `-D api_version=XXXXX` to the
+# cmake command-line where XXXXX is the desired version number. For background see
+# https://bitbucket.org/chromiumembedded/cef/wiki/ApiVersioning.md
+if(DEFINED api_version)
+  string(LENGTH "${api_version}" length)
+  if (NOT length EQUAL 5 OR NOT api_version MATCHES "^[0-9]+$")
+    message(FATAL_ERROR "Expected a 5 digit number for api_version, got '${api_version}'")
+  endif()
+  list(APPEND CEF_COMPILER_DEFINES
+    CEF_API_VERSION=${api_version}
+  )
+endif()
+
+
 #
 # Linux configuration.
 #
@@ -172,6 +186,8 @@ if(OS_LINUX)
   if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     list(APPEND CEF_CXX_COMPILER_FLAGS
       -Wno-attributes             # The cfi-icall attribute is not supported by the GNU C++ compiler
+      -Wno-array-bounds           # Silence "is partly outside array bounds" errors with runtime size check in wrapper
+      -Wno-stringop-overflow      # Silence "overflows the destination" errors with runtime size check in wrapper
       )
   endif()
 
@@ -220,7 +236,6 @@ if(OS_LINUX)
     libGLESv2.so
     libvk_swiftshader.so
     libvulkan.so.1
-    snapshot_blob.bin
     v8_context_snapshot.bin
     vk_swiftshader_icd.json
     )
@@ -311,7 +326,7 @@ if(OS_MAC)
 
   # Find the newest available base SDK.
   execute_process(COMMAND xcode-select --print-path OUTPUT_VARIABLE XCODE_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
-  foreach(OS_VERSION 14.2 14.0 10.15)
+  foreach(OS_VERSION 15.4 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})
@@ -319,7 +334,7 @@ if(OS_MAC)
   endforeach()
 
   # Target SDK.
-  set(CEF_TARGET_SDK               "10.15")
+  set(CEF_TARGET_SDK               "11.0")
   list(APPEND CEF_COMPILER_FLAGS
     -mmacosx-version-min=${CEF_TARGET_SDK}
   )
@@ -346,14 +361,6 @@ if(OS_MAC)
     list(APPEND CEF_COMPILER_DEFINES
       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")
   endif()
 
   # CEF Helper app suffixes.
@@ -381,15 +388,6 @@ if(OS_WINDOWS)
     set(CMAKE_CXX_FLAGS_RELEASE "")
   endif()
 
-  if(USE_SANDBOX)
-    # Check if the current MSVC version is compatible with the cef_sandbox.lib
-    # static library. We require VS2015 or newer.
-    if(MSVC_VERSION LESS 1900)
-      message(WARNING "CEF sandbox is not compatible with the current MSVC version (${MSVC_VERSION})")
-      set(USE_SANDBOX OFF)
-    endif()
-  endif()
-
   # Consumers who run into LNK4099 warnings can pass /Z7 instead (see issue #385).
   set(CEF_DEBUG_INFO_FLAG "/Zi" CACHE STRING "Optional flag specifying specific /Z flag to use")
 
@@ -434,18 +432,20 @@ if(OS_WINDOWS)
   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 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). Lists should be kept in sync with
+  # targets from Chromium's //build/config/win/BUILD.gn file.
+  set(CEF_DELAYLOAD_FLAGS
+    # Required to support CefScopedLibraryLoader.
+    /DELAYLOAD:libcef.dll
+
+    # "delayloads" target.
     /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
@@ -487,6 +487,31 @@ if(OS_WINDOWS)
     /DELAYLOAD:winusb.dll
     /DELAYLOAD:wsock32.dll
     /DELAYLOAD:wtsapi32.dll
+
+    # "delayloads_not_for_child_dll" target.
+    /DELAYLOAD:crypt32.dll
+    /DELAYLOAD:dbghelp.dll
+    /DELAYLOAD:dhcpcsvc.dll
+    /DELAYLOAD:dwrite.dll
+    /DELAYLOAD:iphlpapi.dll
+    /DELAYLOAD:oleaut32.dll
+    /DELAYLOAD:secur32.dll
+    /DELAYLOAD:userenv.dll
+    /DELAYLOAD:winhttp.dll
+    /DELAYLOAD:winmm.dll
+    /DELAYLOAD:winspool.drv
+    /DELAYLOAD:wintrust.dll
+    /DELAYLOAD:ws2_32.dll
+    )
+  list(APPEND CEF_EXE_LINKER_FLAGS
+    # For executable targets.
+    /MANIFEST:NO        # No default manifest (see ADD_WINDOWS_MANIFEST macro usage)
+    /LARGEADDRESSAWARE  # Allow 32-bit processes to access 3GB of RAM
+    ${CEF_DELAYLOAD_FLAGS}
+    )
+  list(APPEND CEF_SHARED_LINKER_FLAGS
+    # For shared library targets.
+    ${CEF_DELAYLOAD_FLAGS}
     )
   list(APPEND CEF_COMPILER_DEFINES
     WIN32 _WIN32 _WINDOWS             # Windows platform
@@ -525,9 +550,12 @@ if(OS_WINDOWS)
   # Standard libraries.
   set(CEF_STANDARD_LIBS
     comctl32.lib
+    crypt32.lib
+    delayimp.lib
     gdi32.lib
     rpcrt4.lib
     shlwapi.lib
+    wintrust.lib
     ws2_32.lib
     )
 
@@ -548,7 +576,6 @@ if(OS_WINDOWS)
     libcef.dll
     libEGL.dll
     libGLESv2.dll
-    snapshot_blob.bin
     v8_context_snapshot.bin
     vk_swiftshader.dll
     vk_swiftshader_icd.json
@@ -573,36 +600,8 @@ if(OS_WINDOWS)
 
   if(USE_SANDBOX)
     list(APPEND CEF_COMPILER_DEFINES
-      PSAPI_VERSION=1   # Required by cef_sandbox.lib
-      CEF_USE_SANDBOX   # Used by apps to test if the sandbox is enabled
+      CEF_USE_BOOTSTRAP   # Used by apps to test if the bootstrap is enabled
       )
-    list(APPEND CEF_COMPILER_DEFINES_DEBUG
-      _HAS_ITERATOR_DEBUGGING=0   # Disable iterator debugging
-      )
-
-    # Libraries required by cef_sandbox.lib.
-    set(CEF_SANDBOX_STANDARD_LIBS
-      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
-      )
-
-    # CEF sandbox library paths.
-    set(CEF_SANDBOX_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/cef_sandbox.lib")
-    set(CEF_SANDBOX_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/cef_sandbox.lib")
   endif()
 
   # Configure use of ATL.

include/base/cef_build.h

@@ -84,12 +84,11 @@
 #endif
 #endif
 
-#if !BUILDFLAG(ENABLE_ALLOY_BOOTSTRAP)
-#define DISABLE_ALLOY_BOOTSTRAP 1
-#endif
-
 #else  // !USING_CHROMIUM_INCLUDES
+
+#if !defined(GENERATING_CEF_API_HASH)
 #include "include/cef_config.h"
+#endif
 
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be

include/base/cef_compiler_specific.h

@@ -313,6 +313,30 @@
 #define STACK_UNINITIALIZED
 #endif
 
+// Attribute "no_stack_protector" disables -fstack-protector for the specified
+// function.
+//
+// "stack_protector" is enabled on most POSIX builds. The flag adds a canary
+// to each stack frame, which on function return is checked against a reference
+// canary. If the canaries do not match, it's likely that a stack buffer
+// overflow has occurred, so immediately crashing will prevent exploitation in
+// many cases.
+//
+// In some cases it's desirable to remove this, e.g. on hot functions, or if
+// we have purposely changed the reference canary.
+//
+// On Linux systems the reference canary will be purposely changed when forking
+// sub-processes (see https://crbug.com/40181003). To avoid sub-process shutdown
+// crashes the NO_STACK_PROTECTOR annotation must be added to all functions in
+// the call stack leading to CefExecuteProcess(). Applications that cannot add
+// this annotation must instead pass the `--change-stack-guard-on-fork=disable`
+// command-line flag.
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define NO_STACK_PROTECTOR __attribute__((no_stack_protector))
+#else
+#define NO_STACK_PROTECTOR
+#endif
+
 // The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
 // to Clang which control what code paths are statically analyzed,
 // and is meant to be used in conjunction with assert & assert-like functions.

include/base/cef_dump_without_crashing.h

@@ -0,0 +1,92 @@
+// 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
+
+#include "include/cef_api_hash.h"
+
+constexpr long long kOneDayInMilliseconds = 86400000;
+
+///
+/// This function allows for generating of crash dumps with a throttling
+/// mechanism, preventing frequent dumps from being generated in a short period
+/// of time from the same location. If should only be called after CefInitialize
+/// has been successfully called. The |function_name|, |file_name|, and
+/// |line_number| parameters specify the origin 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.
+///
+/// For detailed behavior, usage instructions, and considerations, refer to the
+/// documentation of DumpWithoutCrashing in base/debug/dump_without_crashing.h.
+///
+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());
+
+#if CEF_API_REMOVED(13500)
+///
+/// This function allows for generating of crash dumps without any throttling
+/// constraints. If should also only be called after CefInitialize has been
+/// successfully called.
+///
+/// Returns true if the dump was successfully generated, false otherwise.
+///
+/// For detailed behavior, usage instructions, and considerations, refer to the
+/// documentation of DumpWithoutCrashingUnthrottled in
+/// base/debug/dump_without_crashing.h.
+///
+/// This function is removed in API version 13500. Use CefDumpWithoutCrashing()
+/// instead.
+///
+bool CefDumpWithoutCrashingUnthrottled();
+#endif
+
+#endif  // CEF_INCLUDE_BASE_CEF_DUMP_WITHOUT_CRASHING_H_

include/base/cef_immediate_crash.h

@@ -0,0 +1,197 @@
+// Copyright (c) 2025 Marshall A. Greenblatt. Portions copyright (c) 2019
+// 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_IMMEDIATE_CRASH_H_
+#define CEF_INCLUDE_BASE_CEF_IMMEDIATE_CRASH_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/immediate_crash.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 "include/base/cef_build.h"
+
+#if defined(OS_WIN)
+#include <stdlib.h>
+#endif
+
+// Crashes in the fastest possible way with no attempt at logging.
+// There are several constraints; see http://crbug.com/664209 for more context.
+//
+// - TRAP_SEQUENCE_() must be fatal. It should not be possible to ignore the
+//   resulting exception or simply hit 'continue' to skip over it in a debugger.
+// - Different instances of TRAP_SEQUENCE_() must not be folded together, to
+//   ensure crash reports are debuggable. Unlike __builtin_trap(), asm volatile
+//   blocks will not be folded together.
+//   Note: TRAP_SEQUENCE_() previously required an instruction with a unique
+//   nonce since unlike clang, GCC folds together identical asm volatile
+//   blocks.
+// - TRAP_SEQUENCE_() must produce a signal that is distinct from an invalid
+//   memory access.
+// - TRAP_SEQUENCE_() must be treated as a set of noreturn instructions.
+//   __builtin_unreachable() is used to provide that hint here. clang also uses
+//   this as a heuristic to pack the instructions in the function epilogue to
+//   improve code density.
+// - base::ImmediateCrash() is used in allocation hooks. To prevent recursions,
+//   TRAP_SEQUENCE_() must not allocate.
+//
+// Additional properties that are nice to have:
+// - TRAP_SEQUENCE_() should be as compact as possible.
+// - The first instruction of TRAP_SEQUENCE_() should not change, to avoid
+//   shifting crash reporting clusters. As a consequence of this, explicit
+//   assembly is preferred over intrinsics.
+//   Note: this last bullet point may no longer be true, and may be removed in
+//   the future.
+
+// Note: TRAP_SEQUENCE Is currently split into two macro helpers due to the fact
+// that clang emits an actual instruction for __builtin_unreachable() on certain
+// platforms (see https://crbug.com/958675). In addition, the int3/bkpt/brk will
+// be removed in followups, so splitting it up like this now makes it easy to
+// land the followups.
+
+#if defined(COMPILER_GCC)
+
+#if defined(ARCH_CPU_X86_FAMILY)
+
+// TODO(crbug.com/40625592): In theory, it should be possible to use just
+// int3. However, there are a number of crashes with SIGILL as the exception
+// code, so it seems likely that there's a signal handler that allows execution
+// to continue after SIGTRAP.
+#define TRAP_SEQUENCE1_() asm volatile("int3")
+
+#if defined(OS_APPLE)
+// Intentionally empty: __builtin_unreachable() is always part of the sequence
+// (see IMMEDIATE_CRASH below) and already emits a ud2 on Mac.
+#define TRAP_SEQUENCE2_() asm volatile("")
+#else
+#define TRAP_SEQUENCE2_() asm volatile("ud2")
+#endif  // defined(OS_APPLE)
+
+#elif defined(ARCH_CPU_ARMEL)
+
+// bkpt will generate a SIGBUS when running on armv7 and a SIGTRAP when running
+// as a 32 bit userspace app on arm64. There doesn't seem to be any way to
+// cause a SIGTRAP from userspace without using a syscall (which would be a
+// problem for sandboxing).
+// TODO(crbug.com/40625592): Remove bkpt from this sequence.
+#define TRAP_SEQUENCE1_() asm volatile("bkpt #0")
+#define TRAP_SEQUENCE2_() asm volatile("udf #0")
+
+#elif defined(ARCH_CPU_ARM64)
+
+// This will always generate a SIGTRAP on arm64.
+// TODO(crbug.com/40625592): Remove brk from this sequence.
+#define TRAP_SEQUENCE1_() asm volatile("brk #0")
+#define TRAP_SEQUENCE2_() asm volatile("hlt #0")
+
+#else
+
+// Crash report accuracy will not be guaranteed on other architectures, but at
+// least this will crash as expected.
+#define TRAP_SEQUENCE1_() __builtin_trap()
+#define TRAP_SEQUENCE2_() asm volatile("")
+
+#endif  // ARCH_CPU_*
+
+#elif defined(COMPILER_MSVC)
+
+#if !defined(__clang__)
+
+// MSVC x64 doesn't support inline asm, so use the MSVC intrinsic.
+#define TRAP_SEQUENCE1_() __debugbreak()
+#define TRAP_SEQUENCE2_()
+
+#elif defined(ARCH_CPU_ARM64)
+
+// Windows ARM64 uses "BRK #F000" as its breakpoint instruction, and
+// __debugbreak() generates that in both VC++ and clang.
+#define TRAP_SEQUENCE1_() __debugbreak()
+// Intentionally empty: __builtin_unreachable() is always part of the sequence
+// (see IMMEDIATE_CRASH below) and already emits a ud2 on Win64,
+// https://crbug.com/958373
+#define TRAP_SEQUENCE2_() __asm volatile("")
+
+#else
+
+#define TRAP_SEQUENCE1_() asm volatile("int3")
+#define TRAP_SEQUENCE2_() asm volatile("ud2")
+
+#endif  // __clang__
+
+#else
+
+#error No supported trap sequence!
+
+#endif  // COMPILER_GCC
+
+#define TRAP_SEQUENCE_() \
+  do {                   \
+    TRAP_SEQUENCE1_();   \
+    TRAP_SEQUENCE2_();   \
+  } while (false)
+
+// This version of ALWAYS_INLINE inlines even in is_debug=true.
+// TODO(pbos): See if NDEBUG can be dropped from ALWAYS_INLINE as well, and if
+// so merge. Otherwise document why it cannot inline in debug in
+// base/compiler_specific.h.
+#if defined(COMPILER_GCC)
+#define IMMEDIATE_CRASH_ALWAYS_INLINE inline __attribute__((__always_inline__))
+#elif defined(COMPILER_MSVC)
+#define IMMEDIATE_CRASH_ALWAYS_INLINE __forceinline
+#else
+#define IMMEDIATE_CRASH_ALWAYS_INLINE inline
+#endif
+
+namespace base {
+
+[[noreturn]] IMMEDIATE_CRASH_ALWAYS_INLINE void ImmediateCrash() {
+#if defined(OS_WIN)
+  // We can't use abort() on Windows because it results in the
+  // abort/retry/ignore dialog which disrupts automated tests.
+  // TODO(crbug.com/40948553): investigate if such dialogs can
+  // be suppressed
+  TRAP_SEQUENCE_();
+#if defined(__clang__) || defined(COMPILER_GCC)
+  __builtin_unreachable();
+#endif  // defined(__clang__) || defined(COMPILER_GCC)
+#else   // !defined(OS_WIN)
+  abort();
+#endif  // !defined(OS_WIN)
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_LOCK_H_

include/base/cef_logging.h

@@ -189,16 +189,50 @@
 namespace cef {
 namespace logging {
 
+class ScopedEarlySupport;
+
+namespace internal {
+
+// Structure defining the baseline logging implementation used by client
+// and wrapper code that links libcef_dll_wrapper.
+struct Implementation {
+  decltype(&cef_get_min_log_level) get_min_log_level;
+  decltype(&cef_get_vlog_level) get_vlog_level;
+  decltype(&cef_log) log;
+};
+
+// Returns the currently configured logging implementation.
+const Implementation* GetImplementation();
+
+// Change the logging implementation for the lifespan of this scoped object.
+// See ScopedEarlySupport for usage.
+class ScopedImplementation {
+ public:
+  ScopedImplementation(const ScopedImplementation&) = delete;
+  ScopedImplementation& operator=(const ScopedImplementation&) = delete;
+
+ private:
+  friend class logging::ScopedEarlySupport;
+
+  ScopedImplementation();
+  ~ScopedImplementation();
+  void Init(const Implementation* impl);
+
+  const Implementation* previous_ = nullptr;
+};
+
+}  // namespace internal
+
 // Gets the current log level.
 inline int GetMinLogLevel() {
-  return cef_get_min_log_level();
+  return internal::GetImplementation()->get_min_log_level();
 }
 
 // Gets the current vlog level for the given file (usually taken from
 // __FILE__). Note that |N| is the size *with* the null terminator.
 template <size_t N>
 int GetVlogLevel(const char (&file)[N]) {
-  return cef_get_vlog_level(file, N);
+  return internal::GetImplementation()->get_vlog_level(file, N);
 }
 
 typedef int LogSeverity;
@@ -218,6 +252,64 @@ const LogSeverity LOG_DFATAL = LOG_ERROR;
 const LogSeverity LOG_DFATAL = LOG_FATAL;
 #endif
 
+///
+/// Support the use of CEF logging macros during early application startup,
+/// prior to loading libcef. Not for use during or after CEF initialization.
+/// Support is scoped to this object's lifespan. This implementation is not
+/// thread-safe and should not be used for logging from multiple threads.
+///
+class ScopedEarlySupport final : public internal::ScopedImplementation {
+ public:
+  ///
+  /// Logging configuration.
+  ///
+  struct Config {
+    ///
+    /// Configure logging level.
+    ///
+    int min_log_level = LOG_ERROR;
+    int vlog_level = 0;
+
+    ///
+    /// Configure log line formatting.
+    ///
+    const char* log_prefix = nullptr;
+    bool log_process_id = true;
+    bool log_thread_id = true;
+    bool log_timestamp = true;
+    bool log_tickcount = true;
+
+    ///
+    /// Optionally override the default handling of formatted log lines. For
+    /// example, this callback could be used to write |log_line| to a file.
+    /// Return false to proceed with the default behavior of writing to stderr
+    /// or debugger console. FATAL errors will still intentionally crash the
+    /// application.
+    ///
+    bool (*formatted_log_handler)(const char* /*log_line*/) = nullptr;
+  };
+
+  explicit ScopedEarlySupport(const Config& config);
+
+  ScopedEarlySupport(const ScopedEarlySupport&) = delete;
+  ScopedEarlySupport& operator=(const ScopedEarlySupport&) = delete;
+
+ private:
+  static const Config& GetConfig();
+
+  static int get_min_log_level();
+  static int get_vlog_level(const char* file_start, size_t N);
+  static void log(const char* file,
+                  int line,
+                  int severity,
+                  const char* message);
+
+  const struct Impl {
+    internal::Implementation ptrs;
+    Config config;
+  } impl_;
+};
+
 // A few definitions of macros that don't generate much code. These are used
 // by LOG() and LOG_IF, etc. Since these are used all over our code, it's
 // better to have compact code for these operations.

include/capi/cef_accessibility_handler_capi.h

@@ -1,81 +0,0 @@
-// 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=6ea5d772fb4961ae4a658b4b730aa608fa93309f$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-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.
-///
-typedef struct _cef_accessibility_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* on_accessibility_location_change)(
-      struct _cef_accessibility_handler_t* self,
-      struct _cef_value_t* value);
-} cef_accessibility_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_

include/capi/cef_app_capi.h

@@ -1,205 +0,0 @@
-// 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=dfa0d4d2da319b2fd5e92324fd14301b500ceb5c$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_process_handler_capi.h"
-#include "include/capi/cef_command_line_capi.h"
-#include "include/capi/cef_render_process_handler_capi.h"
-#include "include/capi/cef_resource_bundle_handler_capi.h"
-#include "include/capi/cef_scheme_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_app_t;
-
-///
-/// 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.
-  ///
-  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
-  /// 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,
-      const cef_string_t* process_type,
-      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.
-  ///
-  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
-  /// cef_settings_t.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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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 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 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. 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 cef_main_args_t* args,
-                              const struct _cef_settings_t* settings,
-                              cef_app_t* application,
-                              void* windows_sandbox_info);
-
-///
-/// 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
-/// 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
-/// 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.
-///
-CEF_EXPORT void cef_quit_message_loop(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_

include/capi/cef_audio_handler_capi.h

@@ -1,121 +0,0 @@
-// 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=d98482eba93dcd8b6a6f69b2732162733c73203d$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_AUDIO_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 audio events.
-///
-typedef struct _cef_audio_handler_t {
-  ///
-  /// 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.
-  ///
-  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. 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,
-      struct _cef_browser_t* browser,
-      const cef_audio_parameters_t* params,
-      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.
-  ///
-  void(CEF_CALLBACK* on_audio_stream_packet)(struct _cef_audio_handler_t* self,
-                                             struct _cef_browser_t* browser,
-                                             const float** data,
-                                             int frames,
-                                             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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_audio_stream_error)(struct _cef_audio_handler_t* self,
-                                            struct _cef_browser_t* browser,
-                                            const cef_string_t* message);
-} cef_audio_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_

include/capi/cef_auth_callback_capi.h

@@ -1,76 +0,0 @@
-// 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=b63947918eca8c31790cae16b2e8a0be7e9464dd$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure used for asynchronous continuation of authentication
-/// requests.
-///
-typedef struct _cef_auth_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self);
-} cef_auth_callback_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_

include/capi/cef_base_capi.h

@@ -44,62 +44,54 @@ extern "C" {
 #endif
 
 ///
-// All ref-counted framework structures must include this structure first.
+/// All ref-counted framework structures must include this structure first.
 ///
 typedef struct _cef_base_ref_counted_t {
   ///
-  // Size of the data structure.
+  /// Size of the data structure.
   ///
   size_t size;
 
   ///
-  // Called to increment the reference count for the object. Should be called
-  // for every new copy of a pointer to a given object.
+  /// Called to increment the reference count for the object. Should be called
+  /// for every new copy of a pointer to a given object.
   ///
   void(CEF_CALLBACK* add_ref)(struct _cef_base_ref_counted_t* self);
 
   ///
-  // Called to decrement the reference count for the object. If the reference
-  // count falls to 0 the object should self-delete. Returns true (1) if the
-  // resulting reference count is 0.
+  /// Called to decrement the reference count for the object. If the reference
+  /// count falls to 0 the object should self-delete. Returns true (1) if the
+  /// resulting reference count is 0.
   ///
   int(CEF_CALLBACK* release)(struct _cef_base_ref_counted_t* self);
 
   ///
-  // Returns true (1) if the current reference count is 1.
+  /// Returns true (1) if the current reference count is 1.
   ///
   int(CEF_CALLBACK* has_one_ref)(struct _cef_base_ref_counted_t* self);
 
   ///
-  // Returns true (1) if the current reference count is at least 1.
+  /// Returns true (1) if the current reference count is at least 1.
   ///
   int(CEF_CALLBACK* has_at_least_one_ref)(struct _cef_base_ref_counted_t* self);
 } cef_base_ref_counted_t;
 
 ///
-// All scoped framework structures must include this structure first.
+/// All scoped framework structures must include this structure first.
 ///
 typedef struct _cef_base_scoped_t {
   ///
-  // Size of the data structure.
+  /// Size of the data structure.
   ///
   size_t size;
 
   ///
-  // Called to delete this object. May be NULL if the object is not owned.
+  /// Called to delete this object. May be NULL if the object is not owned.
   ///
   void(CEF_CALLBACK* del)(struct _cef_base_scoped_t* self);
 
 } cef_base_scoped_t;
 
-// Check that the structure |s|, which is defined with a size_t member at the
-// top, is large enough to contain the specified member |f|.
-#define CEF_MEMBER_EXISTS(s, f) \
-  ((intptr_t) &                 \
-   ((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= *reinterpret_cast<size_t*>(s))
-
-#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))
-
 #ifdef __cplusplus
 }
 #endif

include/capi/cef_browser_process_handler_capi.h

@@ -1,177 +0,0 @@
-// 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=d958d5bed7f909f6313facef3440fb8ba07a5c01$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
-#pragma once
-
-#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
-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.
-///
-typedef struct _cef_browser_process_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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 and
-  /// cef_settings_t.persist_user_preferences 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 and
-  /// cef_request_context_settings_t.persist_user_preferences 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.
-  ///
-  void(CEF_CALLBACK* on_before_child_process_launch)(
-      struct _cef_browser_process_handler_t* self,
-      struct _cef_command_line_t* command_line);
-
-  ///
-  /// 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_t delay_ms);
-
-  ///
-  /// 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 the Chrome runtime
-  /// 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 the
-  /// Chrome runtime 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
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_

include/capi/cef_callback_capi.h

@@ -1,88 +0,0 @@
-// 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=46bc048bec64590735298a95633167d66e445844$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Generic callback structure used for asynchronous continuation.
-///
-typedef struct _cef_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Continue processing.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_callback_t* self);
-
-  ///
-  /// Cancel processing.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self);
-} cef_callback_t;
-
-///
-/// Generic callback structure used for asynchronous completion.
-///
-typedef struct _cef_completion_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_

include/capi/cef_client_capi.h

@@ -1,210 +0,0 @@
-// 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=09bd4140605645c9dfbd81e7e22d029d0bb50129$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
-#pragma once
-
-#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"
-#include "include/capi/cef_download_handler_capi.h"
-#include "include/capi/cef_drag_handler_capi.h"
-#include "include/capi/cef_find_handler_capi.h"
-#include "include/capi/cef_focus_handler_capi.h"
-#include "include/capi/cef_frame_handler_capi.h"
-#include "include/capi/cef_jsdialog_handler_capi.h"
-#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"
-#include "include/capi/cef_request_handler_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Implement this structure to provide handler implementations.
-///
-typedef struct _cef_client_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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 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.
-  ///
-  struct _cef_dialog_handler_t*(CEF_CALLBACK* get_dialog_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_download_handler_t*(CEF_CALLBACK* get_download_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_find_handler_t*(CEF_CALLBACK* get_find_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_frame_handler_t*(CEF_CALLBACK* get_frame_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_keyboard_handler_t*(CEF_CALLBACK* get_keyboard_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)(
-      struct _cef_client_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* on_process_message_received)(
-      struct _cef_client_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      cef_process_id_t source_process,
-      struct _cef_process_message_t* message);
-} cef_client_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_

include/capi/cef_command_handler_capi.h

@@ -1,120 +0,0 @@
-// 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=dd183a473b1e8c5ee8bdcf99949fc5274c4cc892$
-//
-
-#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 the Chrome runtime.
-  ///
-  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 the Chrome
-  /// runtime.
-  ///
-  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 the Chrome
-  /// runtime.
-  ///
-  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 the Chrome runtime.
-  ///
-  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 the Chrome runtime.
-  ///
-  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,215 +0,0 @@
-// 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=fce786b3f054d6581438e2906b77e573c797372a$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-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.
-///
-typedef struct _cef_command_line_t {
-  ///
-  /// 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).
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* is_read_only)(struct _cef_command_line_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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]* }`
-  ///
-  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.
-  ///
-  // 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).
-  ///
-  // 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).
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* has_switches)(struct _cef_command_line_t* self);
-
-  ///
-  /// 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.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_switch_value)(
-      struct _cef_command_line_t* self,
-      const cef_string_t* name);
-
-  ///
-  /// 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.
-  ///
-  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. 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.
-  ///
-  int(CEF_CALLBACK* has_arguments)(struct _cef_command_line_t* self);
-
-  ///
-  /// 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.
-  ///
-  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".
-  ///
-  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.
-///
-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.
-///
-CEF_EXPORT cef_command_line_t* cef_command_line_get_global(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_

include/capi/cef_context_menu_handler_capi.h

@@ -1,367 +0,0 @@
-// 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=3ae7dbb24ec7a95a2f4d4e390c9b6622221c2f42$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_frame_capi.h"
-#include "include/capi/cef_menu_model_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_context_menu_params_t;
-
-///
-/// Callback structure used for continuation of custom context menu display.
-///
-typedef struct _cef_run_context_menu_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_run_context_menu_callback_t* self);
-} cef_run_context_menu_callback_t;
-
-///
-/// Callback structure used for continuation of custom quick menu display.
-///
-typedef struct _cef_run_quick_menu_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_context_menu_params_t* params,
-      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.
-  ///
-  int(CEF_CALLBACK* run_context_menu)(
-      struct _cef_context_menu_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_context_menu_params_t* params,
-      struct _cef_menu_model_t* model,
-      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.
-  ///
-  int(CEF_CALLBACK* on_context_menu_command)(
-      struct _cef_context_menu_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_context_menu_params_t* params,
-      int command_id,
-      cef_event_flags_t event_flags);
-
-  ///
-  /// 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 functions of this
-/// structure can only be accessed on browser process the UI thread.
-///
-typedef struct _cef_context_menu_params_t {
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self);
-} cef_context_menu_params_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_

include/capi/cef_cookie_capi.h

@@ -1,199 +0,0 @@
-// 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=76ba2e59636aa71c8c6286093198a1e64d012c62$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_callback_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_cookie_visitor_t;
-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.
-///
-typedef struct _cef_cookie_manager_t {
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* visit_url_cookies)(struct _cef_cookie_manager_t* self,
-                                       const cef_string_t* url,
-                                       int includeHttpOnly,
-                                       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.
-  ///
-  int(CEF_CALLBACK* set_cookie)(struct _cef_cookie_manager_t* self,
-                                const cef_string_t* url,
-                                const struct _cef_cookie_t* cookie,
-                                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.
-  ///
-  int(CEF_CALLBACK* delete_cookies)(
-      struct _cef_cookie_manager_t* self,
-      const cef_string_t* url,
-      const cef_string_t* cookie_name,
-      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.
-  ///
-  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
-/// 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.
-///
-typedef struct _cef_cookie_visitor_t {
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* visit)(struct _cef_cookie_visitor_t* self,
-                           const struct _cef_cookie_t* cookie,
-                           int count,
-                           int total,
-                           int* deleteCookie);
-} cef_cookie_visitor_t;
-
-///
-/// 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.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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().
-///
-typedef struct _cef_delete_cookies_callback_t {
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* on_complete)(struct _cef_delete_cookies_callback_t* self,
-                                  int num_deleted);
-} cef_delete_cookies_callback_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_

include/capi/cef_crash_util_capi.h

@@ -1,154 +0,0 @@
-// 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=46a6432f66cce88d8597c3d070681b09a712dc54$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-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:
-///
-/// <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.
-///
-CEF_EXPORT void cef_set_crash_key_value(const cef_string_t* key,
-                                        const cef_string_t* value);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_

include/capi/cef_devtools_message_observer_capi.h

@@ -1,148 +0,0 @@
-// 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=dd94c50619e92bf5bed4fe61479813ee559f779d$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-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.
-///
-typedef struct _cef_dev_tools_message_observer_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* on_dev_tools_message)(
-      struct _cef_dev_tools_message_observer_t* self,
-      struct _cef_browser_t* browser,
-      const void* message,
-      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.
-  ///
-  void(CEF_CALLBACK* on_dev_tools_method_result)(
-      struct _cef_dev_tools_message_observer_t* self,
-      struct _cef_browser_t* browser,
-      int message_id,
-      int success,
-      const void* result,
-      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.
-  ///
-  void(CEF_CALLBACK* on_dev_tools_event)(
-      struct _cef_dev_tools_message_observer_t* self,
-      struct _cef_browser_t* browser,
-      const cef_string_t* method,
-      const void* params,
-      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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_dev_tools_agent_detached)(
-      struct _cef_dev_tools_message_observer_t* self,
-      struct _cef_browser_t* browser);
-} cef_dev_tools_message_observer_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_

include/capi/cef_dialog_handler_capi.h

@@ -1,120 +0,0 @@
-// 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=bf7208a86ee17f63fd7163cef8c3a13373a1f1c8$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure for asynchronous continuation of file dialog requests.
-///
-typedef struct _cef_file_dialog_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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,
-                           cef_string_list_t file_paths);
-
-  ///
-  /// 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.
-///
-typedef struct _cef_dialog_handler_t {
-  ///
-  /// 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 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,
-      struct _cef_browser_t* browser,
-      cef_file_dialog_mode_t mode,
-      const cef_string_t* title,
-      const cef_string_t* default_file_path,
-      cef_string_list_t accept_filters,
-      cef_string_list_t accept_extensions,
-      cef_string_list_t accept_descriptions,
-      struct _cef_file_dialog_callback_t* callback);
-} cef_dialog_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_

include/capi/cef_display_handler_capi.h

@@ -1,178 +0,0 @@
-// 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=5a99c5e88ea0e123087234b2795fa625fed183f2$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_frame_capi.h"
-
-#ifdef __cplusplus
-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.
-///
-typedef struct _cef_display_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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,
-                                        struct _cef_frame_t* frame,
-                                        const cef_string_t* url);
-
-  ///
-  /// 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.
-  ///
-  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. With the Alloy
-  /// runtime the client is responsible for triggering the fullscreen transition
-  /// (for example, by calling cef_window_t::SetFullscreen when using Views).
-  /// With the Chrome runtime 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,
-      struct _cef_browser_t* browser,
-      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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self,
-                                        struct _cef_browser_t* browser,
-                                        cef_log_severity_t level,
-                                        const cef_string_t* message,
-                                        const cef_string_t* source,
-                                        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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_loading_progress_change)(
-      struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser,
-      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.
-  ///
-  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 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
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_

include/capi/cef_dom_capi.h

@@ -1,345 +0,0 @@
-// 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=a4d2f79163205ed4367916546240a6aedc2165f9$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-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.
-///
-typedef struct _cef_domvisitor_t {
-  ///
-  /// 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.
-  ///
-  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.
-///
-typedef struct _cef_domdocument_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns the document type.
-  ///
-  cef_dom_document_type_t(CEF_CALLBACK* get_type)(
-      struct _cef_domdocument_t* self);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_domnode_t*(CEF_CALLBACK* get_body)(
-      struct _cef_domdocument_t* self);
-
-  ///
-  /// 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.
-  ///
-  // 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* has_selection)(struct _cef_domdocument_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* get_selection_end_offset)(struct _cef_domdocument_t* self);
-
-  ///
-  /// 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_complete_url)(
-      struct _cef_domdocument_t* self,
-      const cef_string_t* partialURL);
-} 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.
-///
-typedef struct _cef_domnode_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* is_text)(struct _cef_domnode_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* is_editable)(struct _cef_domnode_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* is_same)(struct _cef_domnode_t* self,
-                             struct _cef_domnode_t* that);
-
-  ///
-  /// 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.
-  ///
-  // 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.
-  ///
-  int(CEF_CALLBACK* set_value)(struct _cef_domnode_t* self,
-                               const cef_string_t* value);
-
-  ///
-  /// 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.
-  ///
-  struct _cef_domdocument_t*(CEF_CALLBACK* get_document)(
-      struct _cef_domnode_t* self);
-
-  ///
-  /// Returns the parent node.
-  ///
-  struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self);
-
-  ///
-  /// Returns the previous sibling node.
-  ///
-  struct _cef_domnode_t*(CEF_CALLBACK* get_previous_sibling)(
-      struct _cef_domnode_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* has_children)(struct _cef_domnode_t* self);
-
-  ///
-  /// Return the first child node.
-  ///
-  struct _cef_domnode_t*(CEF_CALLBACK* get_first_child)(
-      struct _cef_domnode_t* self);
-
-  ///
-  /// Returns the last child node.
-  ///
-  struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)(
-      struct _cef_domnode_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* has_element_attributes)(struct _cef_domnode_t* self);
-
-  ///
-  /// 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|.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_element_attribute)(
-      struct _cef_domnode_t* self,
-      const cef_string_t* attrName);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  // 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 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;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_

include/capi/cef_download_handler_capi.h

@@ -1,151 +0,0 @@
-// 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=7ecfb07a95315ff81937e9f68d419122fc88f1b7$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_download_item_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure used to asynchronously continue a download.
-///
-typedef struct _cef_before_download_callback_t {
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_before_download_callback_t* self,
-                           const cef_string_t* download_path,
-                           int show_dialog);
-} cef_before_download_callback_t;
-
-///
-/// Callback structure used to asynchronously cancel a download.
-///
-typedef struct _cef_download_item_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Call to cancel the download.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_download_item_callback_t* self);
-
-  ///
-  /// Call to pause the download.
-  ///
-  void(CEF_CALLBACK* pause)(struct _cef_download_item_callback_t* self);
-
-  ///
-  /// 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.
-///
-typedef struct _cef_download_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  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,
-      const cef_string_t* suggested_name,
-      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.
-  ///
-  void(CEF_CALLBACK* on_download_updated)(
-      struct _cef_download_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_download_item_t* download_item,
-      struct _cef_download_item_callback_t* callback);
-} cef_download_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_

include/capi/cef_download_item_capi.h

@@ -1,174 +0,0 @@
-// 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=9af8ade3addfd112db41792c4e80682a8143e8c4$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure used to represent a download item.
-///
-typedef struct _cef_download_item_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* is_valid)(struct _cef_download_item_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* is_complete)(struct _cef_download_item_t* self);
-
-  ///
-  /// Returns true (1) if the download has been canceled.
-  ///
-  int(CEF_CALLBACK* is_canceled)(struct _cef_download_item_t* self);
-
-  ///
-  /// Returns true (1) if the download has been interrupted.
-  ///
-  int(CEF_CALLBACK* is_interrupted)(struct _cef_download_item_t* self);
-
-  ///
-  /// 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.
-  ///
-  int64_t(CEF_CALLBACK* get_total_bytes)(struct _cef_download_item_t* self);
-
-  ///
-  /// Returns the number of received bytes.
-  ///
-  int64_t(CEF_CALLBACK* get_received_bytes)(struct _cef_download_item_t* self);
-
-  ///
-  /// Returns the time that the download started.
-  ///
-  cef_basetime_t(CEF_CALLBACK* get_start_time)(
-      struct _cef_download_item_t* self);
-
-  ///
-  /// Returns the time that the download ended.
-  ///
-  cef_basetime_t(CEF_CALLBACK* get_end_time)(struct _cef_download_item_t* self);
-
-  ///
-  /// 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.
-  ///
-  uint32_t(CEF_CALLBACK* get_id)(struct _cef_download_item_t* self);
-
-  ///
-  /// 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_mime_type)(
-      struct _cef_download_item_t* self);
-} cef_download_item_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_

include/capi/cef_drag_data_capi.h

@@ -1,240 +0,0 @@
-// 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=a096775255ddc4d7616095e48e7370bd87bf4bb5$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_image_capi.h"
-#include "include/capi/cef_stream_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// 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.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* is_read_only)(struct _cef_drag_data_t* self);
-
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* is_fragment)(struct _cef_drag_data_t* self);
-
-  ///
-  /// 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  // 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* get_file_names)(struct _cef_drag_data_t* self,
-                                    cef_string_list_t names);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* reset_file_contents)(struct _cef_drag_data_t* self);
-
-  ///
-  /// 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);
-
-  ///
-  /// 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).
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self);
-} cef_drag_data_t;
-
-///
-/// Create a new cef_drag_data_t object.
-///
-CEF_EXPORT cef_drag_data_t* cef_drag_data_create(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_

include/capi/cef_drag_handler_capi.h

@@ -1,92 +0,0 @@
-// 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=0723a2a59d46e465ac94f198351dc871f0b35b96$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_drag_data_capi.h"
-#include "include/capi/cef_frame_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* on_drag_enter)(struct _cef_drag_handler_t* self,
-                                   struct _cef_browser_t* browser,
-                                   struct _cef_drag_data_t* dragData,
-                                   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.
-  ///
-  void(CEF_CALLBACK* on_draggable_regions_changed)(
-      struct _cef_drag_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      size_t regionsCount,
-      cef_draggable_region_t const* regions);
-} cef_drag_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_

include/capi/cef_extension_capi.h

@@ -1,132 +0,0 @@
-// 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=634054ad25154c30fb4ec630fe7fb79b0cf1f9b3$
-//
-
-#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.
-///
-/// WARNING: This API is deprecated and will be removed in ~M127.
-///
-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,214 +0,0 @@
-// 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=ebac34c9b85de780ce7524211c5dd61a80d4576c$
-//
-
-#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.
-///
-/// WARNING: This API is deprecated and will be removed in ~M127.
-///
-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,132 +0,0 @@
-// 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=e10581d1f6aeb104646ae106aaa5fb36016643dd$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-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.
-///
-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).
-///
-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.
-///
-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.
-///
-CEF_EXPORT int cef_create_temp_directory_in_directory(
-    const cef_string_t* base_dir,
-    const cef_string_t* prefix,
-    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.
-///
-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.
-///
-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.
-///
-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.
-///
-CEF_EXPORT void cef_load_crlsets_file(const cef_string_t* path);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_

include/capi/cef_find_handler_capi.h

@@ -1,82 +0,0 @@
-// 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=da0a9242b309fbd70d19949fb1c5b4ec4475ef94$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_FIND_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 find results. The
-/// functions of this structure will be called on the UI thread.
-///
-typedef struct _cef_find_handler_t {
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
-                                     struct _cef_browser_t* browser,
-                                     int identifier,
-                                     int count,
-                                     const cef_rect_t* selectionRect,
-                                     int activeMatchOrdinal,
-                                     int finalUpdate);
-} cef_find_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_

include/capi/cef_focus_handler_capi.h

@@ -1,93 +0,0 @@
-// 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=6eefc2c650908461fb7536dd3314c77a3f89dceb$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_dom_capi.h"
-#include "include/capi/cef_frame_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_got_focus)(struct _cef_focus_handler_t* self,
-                                   struct _cef_browser_t* browser);
-} cef_focus_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_

include/capi/cef_frame_capi.h

@@ -1,257 +0,0 @@
-// 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=8f347a95168778ec0e686cdef93be3bc517e2f68$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_dom_capi.h"
-#include "include/capi/cef_process_message_capi.h"
-#include "include/capi/cef_request_capi.h"
-#include "include/capi/cef_stream_capi.h"
-#include "include/capi/cef_string_visitor_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_browser_t;
-struct _cef_urlrequest_client_t;
-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.
-///
-typedef struct _cef_frame_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* undo)(struct _cef_frame_t* self);
-
-  ///
-  /// Execute redo in this frame.
-  ///
-  void(CEF_CALLBACK* redo)(struct _cef_frame_t* self);
-
-  ///
-  /// Execute cut in this frame.
-  ///
-  void(CEF_CALLBACK* cut)(struct _cef_frame_t* self);
-
-  ///
-  /// Execute copy in this frame.
-  ///
-  void(CEF_CALLBACK* copy)(struct _cef_frame_t* self);
-
-  ///
-  /// Execute paste in this frame.
-  ///
-  void(CEF_CALLBACK* paste)(struct _cef_frame_t* self);
-
-  ///
-  /// Execute delete in this frame.
-  ///
-  void(CEF_CALLBACK* del)(struct _cef_frame_t* self);
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* view_source)(struct _cef_frame_t* self);
-
-  ///
-  /// 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.
-  ///
-  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).
-  ///
-  void(CEF_CALLBACK* load_request)(struct _cef_frame_t* self,
-                                   struct _cef_request_t* request);
-
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* execute_java_script)(struct _cef_frame_t* self,
-                                          const cef_string_t* code,
-                                          const cef_string_t* script_url,
-                                          int start_line);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  // 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 NULL if the
-  /// underlying frame does not yet exist.
-  ///
-  // 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.
-  ///
-  struct _cef_frame_t*(CEF_CALLBACK* get_parent)(struct _cef_frame_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  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.
-  ///
-  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. 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,
-      struct _cef_request_t* request,
-      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.
-  ///
-  void(CEF_CALLBACK* send_process_message)(
-      struct _cef_frame_t* self,
-      cef_process_id_t target_process,
-      struct _cef_process_message_t* message);
-} cef_frame_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_

include/capi/cef_frame_handler_capi.h

@@ -1,195 +0,0 @@
-// 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=fc6fbee765ce2b649f5293c8c4b076d36014e4aa$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_frame_capi.h"
-
-#ifdef __cplusplus
-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 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.
-  ///
-  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|.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_frame_attached)(struct _cef_frame_handler_t* self,
-                                        struct _cef_browser_t* browser,
-                                        struct _cef_frame_t* frame,
-                                        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|.
-  ///
-  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|.
-  ///
-  void(CEF_CALLBACK* on_main_frame_changed)(struct _cef_frame_handler_t* self,
-                                            struct _cef_browser_t* browser,
-                                            struct _cef_frame_t* old_frame,
-                                            struct _cef_frame_t* new_frame);
-} cef_frame_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_

include/capi/cef_i18n_util_capi.h

@@ -1,58 +0,0 @@
-// 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=990e80ab5ae04298e6b70cbc0a67115825563251$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Returns true (1) if the application text direction is right-to-left.
-///
-CEF_EXPORT int cef_is_rtl(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_

include/capi/cef_image_capi.h

@@ -1,206 +0,0 @@
-// 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=7512ccf755017d5b1866b753890b498e8163006d$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-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.
-///
-typedef struct _cef_image_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self,
-                                float scale_factor,
-                                int pixel_width,
-                                int pixel_height,
-                                cef_color_type_t color_type,
-                                cef_alpha_type_t alpha_type,
-                                const void* pixel_data,
-                                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.
-  ///
-  int(CEF_CALLBACK* add_png)(struct _cef_image_t* self,
-                             float scale_factor,
-                             const void* png_data,
-                             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.
-  ///
-  int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self,
-                              float scale_factor,
-                              const void* jpeg_data,
-                              size_t jpeg_data_size);
-
-  ///
-  /// 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.
-  ///
-  size_t(CEF_CALLBACK* get_height)(struct _cef_image_t* self);
-
-  ///
-  /// 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.
-  ///
-  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.
-  ///
-  int(CEF_CALLBACK* get_representation_info)(struct _cef_image_t* self,
-                                             float scale_factor,
-                                             float* actual_scale_factor,
-                                             int* pixel_width,
-                                             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.
-  ///
-  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)(
-      struct _cef_image_t* self,
-      float scale_factor,
-      cef_color_type_t color_type,
-      cef_alpha_type_t alpha_type,
-      int* pixel_width,
-      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.
-  ///
-  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)(
-      struct _cef_image_t* self,
-      float scale_factor,
-      int with_transparency,
-      int* pixel_width,
-      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.
-  ///
-  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)(
-      struct _cef_image_t* self,
-      float scale_factor,
-      int quality,
-      int* pixel_width,
-      int* pixel_height);
-} 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.
-///
-CEF_EXPORT cef_image_t* cef_image_create(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_

include/capi/cef_jsdialog_handler_capi.h

@@ -1,141 +0,0 @@
-// 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=c6810367ba3a17824247dcb17f87040cd021c295$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure used for asynchronous continuation of JavaScript dialog
-/// requests.
-///
-typedef struct _cef_jsdialog_callback_t {
-  ///
-  /// 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.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_jsdialog_callback_t* self,
-                           int success,
-                           const cef_string_t* user_input);
-} 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.
-///
-typedef struct _cef_jsdialog_handler_t {
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self,
-                                 struct _cef_browser_t* browser,
-                                 const cef_string_t* origin_url,
-                                 cef_jsdialog_type_t dialog_type,
-                                 const cef_string_t* message_text,
-                                 const cef_string_t* default_prompt_text,
-                                 struct _cef_jsdialog_callback_t* callback,
-                                 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.
-  ///
-  int(CEF_CALLBACK* on_before_unload_dialog)(
-      struct _cef_jsdialog_handler_t* self,
-      struct _cef_browser_t* browser,
-      const cef_string_t* message_text,
-      int is_reload,
-      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.
-  ///
-  void(CEF_CALLBACK* on_reset_dialog_state)(
-      struct _cef_jsdialog_handler_t* self,
-      struct _cef_browser_t* browser);
-
-  ///
-  /// Called when the dialog is closed.
-  ///
-  void(CEF_CALLBACK* on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
-                                       struct _cef_browser_t* browser);
-} cef_jsdialog_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_

include/capi/cef_keyboard_handler_capi.h

@@ -1,90 +0,0 @@
-// 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=0bfe161c51cc6378b2e8e2e2b2c017b750b46864$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_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 keyboard input. The
-/// functions of this structure will be called on the UI thread.
-///
-typedef struct _cef_keyboard_handler_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self,
-                                      struct _cef_browser_t* browser,
-                                      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.
-  ///
-  int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self,
-                                  struct _cef_browser_t* browser,
-                                  const cef_key_event_t* event,
-                                  cef_event_handle_t os_event);
-} cef_keyboard_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_

include/capi/cef_life_span_handler_capi.h

@@ -1,253 +0,0 @@
-// 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=54edf9e9c2a12acdc4cab55079a4a5cb8e2a1e43$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-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.
-///
-typedef struct _cef_life_span_handler_t {
-  ///
-  /// 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.
-  ///
-  int(CEF_CALLBACK* on_before_popup)(
-      struct _cef_life_span_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      const cef_string_t* target_url,
-      const cef_string_t* target_frame_name,
-      cef_window_open_disposition_t target_disposition,
-      int user_gesture,
-      const cef_popup_features_t* popupFeatures,
-      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* no_javascript_access);
-
-  ///
-  /// 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 the Chrome runtime.
-  ///
-  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 received 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.
-  ///
-  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.
-  ///
-  void(CEF_CALLBACK* on_before_close)(struct _cef_life_span_handler_t* self,
-                                      struct _cef_browser_t* browser);
-} cef_life_span_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_

include/capi/cef_load_handler_capi.h

@@ -1,126 +0,0 @@
-// 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=eb842e65cd2e7c4a8a6baa2813b57ac0d3977261$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_frame_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Implement this structure to handle events related to browser load status.
-/// The functions of this structure will be called on the browser process UI
-/// thread or render process main thread (TID_RENDERER).
-///
-typedef struct _cef_load_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called when the loading state has changed. This callback will be executed
-  /// twice -- once when loading is initiated either programmatically or by user
-  /// action, and once when loading is terminated due to completion,
-  /// cancellation of failure. It will be called before any calls to OnLoadStart
-  /// and after all calls to OnLoadError and/or OnLoadEnd.
-  ///
-  void(CEF_CALLBACK* on_loading_state_change)(struct _cef_load_handler_t* self,
-                                              struct _cef_browser_t* browser,
-                                              int isLoading,
-                                              int canGoBack,
-                                              int canGoForward);
-
-  ///
-  /// Called after a navigation has been committed and before the browser begins
-  /// loading contents in the frame. The |frame| value will never be NULL --
-  /// call the is_main() function to check if this frame is the main frame.
-  /// |transition_type| provides information about the source of the navigation
-  /// and an accurate value is only available in the browser process. Multiple
-  /// frames may be loading at the same time. Sub-frames may start or continue
-  /// loading after the main frame load has ended. This function will not be
-  /// called for same page navigations (fragments, history state, etc.) or for
-  /// navigations that fail or are canceled before commit. For notification of
-  /// overall browser load status use OnLoadingStateChange instead.
-  ///
-  void(CEF_CALLBACK* on_load_start)(struct _cef_load_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    struct _cef_frame_t* frame,
-                                    cef_transition_type_t transition_type);
-
-  ///
-  /// Called when the browser is done loading a frame. The |frame| value will
-  /// never be NULL -- call the is_main() function to check if this frame is the
-  /// main frame. Multiple frames may be loading at the same time. Sub-frames
-  /// may start or continue loading after the main frame load has ended. This
-  /// function will not be called for same page navigations (fragments, history
-  /// state, etc.) or for navigations that fail or are canceled before commit.
-  /// For notification of overall browser load status use OnLoadingStateChange
-  /// instead.
-  ///
-  void(CEF_CALLBACK* on_load_end)(struct _cef_load_handler_t* self,
-                                  struct _cef_browser_t* browser,
-                                  struct _cef_frame_t* frame,
-                                  int httpStatusCode);
-
-  ///
-  /// Called when a navigation fails or is canceled. This function may be called
-  /// by itself if before commit or in combination with OnLoadStart/OnLoadEnd if
-  /// after commit. |errorCode| is the error code number, |errorText| is the
-  /// error text and |failedUrl| is the URL that failed to load. See
-  /// net\base\net_error_list.h for complete descriptions of the error codes.
-  ///
-  void(CEF_CALLBACK* on_load_error)(struct _cef_load_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    struct _cef_frame_t* frame,
-                                    cef_errorcode_t errorCode,
-                                    const cef_string_t* errorText,
-                                    const cef_string_t* failedUrl);
-} cef_load_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_

include/capi/cef_media_access_handler_capi.h

@@ -1,108 +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=91101808168ec0faf1f39b1924579e31478a6616$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-// Callback structure used for asynchronous continuation of media access
-// permission requests.
-///
-typedef struct _cef_media_access_callback_t {
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Call to allow or deny media access. If this callback was initiated in
-  // response to a getUserMedia (indicated by
-  // CEF_MEDIA_PERMISSION_DEVICE_AUDIO_CAPTURE and/or
-  // CEF_MEDIA_PERMISSION_DEVICE_VIDEO_CAPTURE being set) the
-  // |allowed_permissions| are required to match those given in
-  // |required_permissions| in the OnRequestMediaAccessPermission.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_media_access_callback_t* self,
-                           int allowed_permissions);
-
-  ///
-  // Cancel the media access request.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_media_access_callback_t* self);
-} cef_media_access_callback_t;
-
-///
-// Implement this structure to handle events related to media access permission
-// requests. The functions of this structure will be called on the browser
-// process UI thread.
-///
-typedef struct _cef_media_access_handler_t {
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Called when a page requests permission to access media. |requesting_url| is
-  // the URL requesting permission. Return true (1) and call
-  // cef_media_access_callback_t::cont() either in this function or at a later
-  // time to continue or cancel the request. Return false (0) to cancel the
-  // request immediately.
-  ///
-  int(CEF_CALLBACK* on_request_media_access_permission)(
-      struct _cef_media_access_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      const cef_string_t* requesting_url,
-      int32_t requested_permissions,
-      struct _cef_media_access_callback_t* callback);
-} cef_media_access_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_MEDIA_ACCESS_HANDLER_CAPI_H_

include/capi/cef_media_router_capi.h

@@ -1,342 +0,0 @@
-// 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=8eec1100e8470cbe3ebc54d5962416d2fa4d57fb$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_callback_capi.h"
-#include "include/capi/cef_registration_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_media_observer_t;
-struct _cef_media_route_create_callback_t;
-struct _cef_media_route_t;
-struct _cef_media_sink_device_info_callback_t;
-struct _cef_media_sink_t;
-struct _cef_media_source_t;
-
-///
-/// Supports discovery of and communication with media devices on the local
-/// network via the Cast and DIAL protocols. The functions of this structure may
-/// be called on any browser process thread unless otherwise indicated.
-///
-typedef struct _cef_media_router_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Add an observer for MediaRouter events. The observer will remain
-  /// registered until the returned Registration object is destroyed.
-  ///
-  struct _cef_registration_t*(CEF_CALLBACK* add_observer)(
-      struct _cef_media_router_t* self,
-      struct _cef_media_observer_t* observer);
-
-  ///
-  /// Returns a MediaSource object for the specified media source URN. Supported
-  /// URN schemes include "cast:" and "dial:", and will be already known by the
-  /// client application (e.g. "cast:<appId>?clientId=<clientId>").
-  ///
-  struct _cef_media_source_t*(CEF_CALLBACK* get_source)(
-      struct _cef_media_router_t* self,
-      const cef_string_t* urn);
-
-  ///
-  /// Trigger an asynchronous call to cef_media_observer_t::OnSinks on all
-  /// registered observers.
-  ///
-  void(CEF_CALLBACK* notify_current_sinks)(struct _cef_media_router_t* self);
-
-  ///
-  /// Create a new route between |source| and |sink|. Source and sink must be
-  /// valid, compatible (as reported by cef_media_sink_t::IsCompatibleWith), and
-  /// a route between them must not already exist. |callback| will be executed
-  /// on success or failure. If route creation succeeds it will also trigger an
-  /// asynchronous call to cef_media_observer_t::OnRoutes on all registered
-  /// observers.
-  ///
-  void(CEF_CALLBACK* create_route)(
-      struct _cef_media_router_t* self,
-      struct _cef_media_source_t* source,
-      struct _cef_media_sink_t* sink,
-      struct _cef_media_route_create_callback_t* callback);
-
-  ///
-  /// Trigger an asynchronous call to cef_media_observer_t::OnRoutes on all
-  /// registered observers.
-  ///
-  void(CEF_CALLBACK* notify_current_routes)(struct _cef_media_router_t* self);
-} cef_media_router_t;
-
-///
-/// Returns the MediaRouter object associated with the global request context.
-/// If |callback| is non-NULL it will be executed asnychronously on the UI
-/// thread after the manager's storage has been initialized. Equivalent to
-/// calling cef_request_context_t::cef_request_context_get_global_context()-
-/// >get_media_router().
-///
-CEF_EXPORT cef_media_router_t* cef_media_router_get_global(
-    struct _cef_completion_callback_t* callback);
-
-///
-/// Implemented by the client to observe MediaRouter events and registered via
-/// cef_media_router_t::AddObserver. The functions of this structure will be
-/// called on the browser process UI thread.
-///
-typedef struct _cef_media_observer_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// The list of available media sinks has changed or
-  /// cef_media_router_t::NotifyCurrentSinks was called.
-  ///
-  void(CEF_CALLBACK* on_sinks)(struct _cef_media_observer_t* self,
-                               size_t sinksCount,
-                               struct _cef_media_sink_t* const* sinks);
-
-  ///
-  /// The list of available media routes has changed or
-  /// cef_media_router_t::NotifyCurrentRoutes was called.
-  ///
-  void(CEF_CALLBACK* on_routes)(struct _cef_media_observer_t* self,
-                                size_t routesCount,
-                                struct _cef_media_route_t* const* routes);
-
-  ///
-  /// The connection state of |route| has changed.
-  ///
-  void(CEF_CALLBACK* on_route_state_changed)(
-      struct _cef_media_observer_t* self,
-      struct _cef_media_route_t* route,
-      cef_media_route_connection_state_t state);
-
-  ///
-  /// A message was received over |route|. |message| is only valid for the scope
-  /// of this callback and should be copied if necessary.
-  ///
-  void(CEF_CALLBACK* on_route_message_received)(
-      struct _cef_media_observer_t* self,
-      struct _cef_media_route_t* route,
-      const void* message,
-      size_t message_size);
-} cef_media_observer_t;
-
-///
-/// Represents the route between a media source and sink. Instances of this
-/// object are created via cef_media_router_t::CreateRoute and retrieved via
-/// cef_media_observer_t::OnRoutes. Contains the status and metadata of a
-/// routing operation. The functions of this structure may be called on any
-/// browser process thread unless otherwise indicated.
-///
-typedef struct _cef_media_route_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns the ID for this route.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_route_t* self);
-
-  ///
-  /// Returns the source associated with this route.
-  ///
-  struct _cef_media_source_t*(CEF_CALLBACK* get_source)(
-      struct _cef_media_route_t* self);
-
-  ///
-  /// Returns the sink associated with this route.
-  ///
-  struct _cef_media_sink_t*(CEF_CALLBACK* get_sink)(
-      struct _cef_media_route_t* self);
-
-  ///
-  /// Send a message over this route. |message| will be copied if necessary.
-  ///
-  void(CEF_CALLBACK* send_route_message)(struct _cef_media_route_t* self,
-                                         const void* message,
-                                         size_t message_size);
-
-  ///
-  /// Terminate this route. Will result in an asynchronous call to
-  /// cef_media_observer_t::OnRoutes on all registered observers.
-  ///
-  void(CEF_CALLBACK* terminate)(struct _cef_media_route_t* self);
-} cef_media_route_t;
-
-///
-/// Callback structure for cef_media_router_t::CreateRoute. The functions of
-/// this structure will be called on the browser process UI thread.
-///
-typedef struct _cef_media_route_create_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Method that will be executed when the route creation has finished.
-  /// |result| will be CEF_MRCR_OK if the route creation succeeded. |error| will
-  /// be a description of the error if the route creation failed. |route| is the
-  /// resulting route, or NULL if the route creation failed.
-  ///
-  void(CEF_CALLBACK* on_media_route_create_finished)(
-      struct _cef_media_route_create_callback_t* self,
-      cef_media_route_create_result_t result,
-      const cef_string_t* error,
-      struct _cef_media_route_t* route);
-} cef_media_route_create_callback_t;
-
-///
-/// Represents a sink to which media can be routed. Instances of this object are
-/// retrieved via cef_media_observer_t::OnSinks. The functions of this structure
-/// may be called on any browser process thread unless otherwise indicated.
-///
-typedef struct _cef_media_sink_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns the ID for this sink.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_sink_t* self);
-
-  ///
-  /// Returns the name of this sink.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_media_sink_t* self);
-
-  ///
-  /// Returns the icon type for this sink.
-  ///
-  cef_media_sink_icon_type_t(CEF_CALLBACK* get_icon_type)(
-      struct _cef_media_sink_t* self);
-
-  ///
-  /// Asynchronously retrieves device info.
-  ///
-  void(CEF_CALLBACK* get_device_info)(
-      struct _cef_media_sink_t* self,
-      struct _cef_media_sink_device_info_callback_t* callback);
-
-  ///
-  /// Returns true (1) if this sink accepts content via Cast.
-  ///
-  int(CEF_CALLBACK* is_cast_sink)(struct _cef_media_sink_t* self);
-
-  ///
-  /// Returns true (1) if this sink accepts content via DIAL.
-  ///
-  int(CEF_CALLBACK* is_dial_sink)(struct _cef_media_sink_t* self);
-
-  ///
-  /// Returns true (1) if this sink is compatible with |source|.
-  ///
-  int(CEF_CALLBACK* is_compatible_with)(struct _cef_media_sink_t* self,
-                                        struct _cef_media_source_t* source);
-} cef_media_sink_t;
-
-///
-/// Callback structure for cef_media_sink_t::GetDeviceInfo. The functions of
-/// this structure will be called on the browser process UI thread.
-///
-typedef struct _cef_media_sink_device_info_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Method that will be executed asyncronously once device information has
-  /// been retrieved.
-  ///
-  void(CEF_CALLBACK* on_media_sink_device_info)(
-      struct _cef_media_sink_device_info_callback_t* self,
-      const struct _cef_media_sink_device_info_t* device_info);
-} cef_media_sink_device_info_callback_t;
-
-///
-/// Represents a source from which media can be routed. Instances of this object
-/// are retrieved via cef_media_router_t::GetSource. The functions of this
-/// structure may be called on any browser process thread unless otherwise
-/// indicated.
-///
-typedef struct _cef_media_source_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns the ID (media source URN or URL) for this source.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_id)(struct _cef_media_source_t* self);
-
-  ///
-  /// Returns true (1) if this source outputs its content via Cast.
-  ///
-  int(CEF_CALLBACK* is_cast_source)(struct _cef_media_source_t* self);
-
-  ///
-  /// Returns true (1) if this source outputs its content via DIAL.
-  ///
-  int(CEF_CALLBACK* is_dial_source)(struct _cef_media_source_t* self);
-} cef_media_source_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_

include/capi/cef_menu_model_capi.h

@@ -1,517 +0,0 @@
-// 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=5dae0b1a1271e79a5fd9b2c6e71e7a719a450161$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_menu_model_delegate_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Supports creation and modification of menus. 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. The functions of
-/// this structure can only be accessed on the browser process the UI thread.
-///
-typedef struct _cef_menu_model_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if this menu is a submenu.
-  ///
-  int(CEF_CALLBACK* is_sub_menu)(struct _cef_menu_model_t* self);
-
-  ///
-  /// Clears the menu. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* clear)(struct _cef_menu_model_t* self);
-
-  ///
-  /// Returns the number of items in this menu.
-  ///
-  size_t(CEF_CALLBACK* get_count)(struct _cef_menu_model_t* self);
-
-  ///
-  /// Add a separator to the menu. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* add_separator)(struct _cef_menu_model_t* self);
-
-  ///
-  /// Add an item to the menu. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* add_item)(struct _cef_menu_model_t* self,
-                              int command_id,
-                              const cef_string_t* label);
-
-  ///
-  /// Add a check item to the menu. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* add_check_item)(struct _cef_menu_model_t* self,
-                                    int command_id,
-                                    const cef_string_t* label);
-
-  ///
-  /// Add a radio item to the menu. Only a single item with the specified
-  /// |group_id| can be checked at a time. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* add_radio_item)(struct _cef_menu_model_t* self,
-                                    int command_id,
-                                    const cef_string_t* label,
-                                    int group_id);
-
-  ///
-  /// Add a sub-menu to the menu. The new sub-menu is returned.
-  ///
-  struct _cef_menu_model_t*(CEF_CALLBACK* add_sub_menu)(
-      struct _cef_menu_model_t* self,
-      int command_id,
-      const cef_string_t* label);
-
-  ///
-  /// Insert a separator in the menu at the specified |index|. Returns true (1)
-  /// on success.
-  ///
-  int(CEF_CALLBACK* insert_separator_at)(struct _cef_menu_model_t* self,
-                                         size_t index);
-
-  ///
-  /// Insert an item in the menu at the specified |index|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* insert_item_at)(struct _cef_menu_model_t* self,
-                                    size_t index,
-                                    int command_id,
-                                    const cef_string_t* label);
-
-  ///
-  /// Insert a check item in the menu at the specified |index|. Returns true (1)
-  /// on success.
-  ///
-  int(CEF_CALLBACK* insert_check_item_at)(struct _cef_menu_model_t* self,
-                                          size_t index,
-                                          int command_id,
-                                          const cef_string_t* label);
-
-  ///
-  /// Insert a radio item in the menu at the specified |index|. Only a single
-  /// item with the specified |group_id| can be checked at a time. Returns true
-  /// (1) on success.
-  ///
-  int(CEF_CALLBACK* insert_radio_item_at)(struct _cef_menu_model_t* self,
-                                          size_t index,
-                                          int command_id,
-                                          const cef_string_t* label,
-                                          int group_id);
-
-  ///
-  /// Insert a sub-menu in the menu at the specified |index|. The new sub-menu
-  /// is returned.
-  ///
-  struct _cef_menu_model_t*(CEF_CALLBACK* insert_sub_menu_at)(
-      struct _cef_menu_model_t* self,
-      size_t index,
-      int command_id,
-      const cef_string_t* label);
-
-  ///
-  /// Removes the item with the specified |command_id|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* remove)(struct _cef_menu_model_t* self, int command_id);
-
-  ///
-  /// Removes the item at the specified |index|. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* remove_at)(struct _cef_menu_model_t* self, size_t index);
-
-  ///
-  /// Returns the index associated with the specified |command_id| or -1 if not
-  /// found due to the command id not existing in the menu.
-  ///
-  int(CEF_CALLBACK* get_index_of)(struct _cef_menu_model_t* self,
-                                  int command_id);
-
-  ///
-  /// Returns the command id at the specified |index| or -1 if not found due to
-  /// invalid range or the index being a separator.
-  ///
-  int(CEF_CALLBACK* get_command_id_at)(struct _cef_menu_model_t* self,
-                                       size_t index);
-
-  ///
-  /// Sets the command id at the specified |index|. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_command_id_at)(struct _cef_menu_model_t* self,
-                                       size_t index,
-                                       int command_id);
-
-  ///
-  /// Returns the label for the specified |command_id| or NULL if not found.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_label)(struct _cef_menu_model_t* self,
-                                                 int command_id);
-
-  ///
-  /// Returns the label at the specified |index| or NULL if not found due to
-  /// invalid range or the index being a separator.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(
-      CEF_CALLBACK* get_label_at)(struct _cef_menu_model_t* self, size_t index);
-
-  ///
-  /// Sets the label for the specified |command_id|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* set_label)(struct _cef_menu_model_t* self,
-                               int command_id,
-                               const cef_string_t* label);
-
-  ///
-  /// Set the label at the specified |index|. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_label_at)(struct _cef_menu_model_t* self,
-                                  size_t index,
-                                  const cef_string_t* label);
-
-  ///
-  /// Returns the item type for the specified |command_id|.
-  ///
-  cef_menu_item_type_t(CEF_CALLBACK* get_type)(struct _cef_menu_model_t* self,
-                                               int command_id);
-
-  ///
-  /// Returns the item type at the specified |index|.
-  ///
-  cef_menu_item_type_t(
-      CEF_CALLBACK* get_type_at)(struct _cef_menu_model_t* self, size_t index);
-
-  ///
-  /// Returns the group id for the specified |command_id| or -1 if invalid.
-  ///
-  int(CEF_CALLBACK* get_group_id)(struct _cef_menu_model_t* self,
-                                  int command_id);
-
-  ///
-  /// Returns the group id at the specified |index| or -1 if invalid.
-  ///
-  int(CEF_CALLBACK* get_group_id_at)(struct _cef_menu_model_t* self,
-                                     size_t index);
-
-  ///
-  /// Sets the group id for the specified |command_id|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* set_group_id)(struct _cef_menu_model_t* self,
-                                  int command_id,
-                                  int group_id);
-
-  ///
-  /// Sets the group id at the specified |index|. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_group_id_at)(struct _cef_menu_model_t* self,
-                                     size_t index,
-                                     int group_id);
-
-  ///
-  /// Returns the submenu for the specified |command_id| or NULL if invalid.
-  ///
-  struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu)(
-      struct _cef_menu_model_t* self,
-      int command_id);
-
-  ///
-  /// Returns the submenu at the specified |index| or NULL if invalid.
-  ///
-  struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu_at)(
-      struct _cef_menu_model_t* self,
-      size_t index);
-
-  ///
-  /// Returns true (1) if the specified |command_id| is visible.
-  ///
-  int(CEF_CALLBACK* is_visible)(struct _cef_menu_model_t* self, int command_id);
-
-  ///
-  /// Returns true (1) if the specified |index| is visible.
-  ///
-  int(CEF_CALLBACK* is_visible_at)(struct _cef_menu_model_t* self,
-                                   size_t index);
-
-  ///
-  /// Change the visibility of the specified |command_id|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* set_visible)(struct _cef_menu_model_t* self,
-                                 int command_id,
-                                 int visible);
-
-  ///
-  /// Change the visibility at the specified |index|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* set_visible_at)(struct _cef_menu_model_t* self,
-                                    size_t index,
-                                    int visible);
-
-  ///
-  /// Returns true (1) if the specified |command_id| is enabled.
-  ///
-  int(CEF_CALLBACK* is_enabled)(struct _cef_menu_model_t* self, int command_id);
-
-  ///
-  /// Returns true (1) if the specified |index| is enabled.
-  ///
-  int(CEF_CALLBACK* is_enabled_at)(struct _cef_menu_model_t* self,
-                                   size_t index);
-
-  ///
-  /// Change the enabled status of the specified |command_id|. Returns true (1)
-  /// on success.
-  ///
-  int(CEF_CALLBACK* set_enabled)(struct _cef_menu_model_t* self,
-                                 int command_id,
-                                 int enabled);
-
-  ///
-  /// Change the enabled status at the specified |index|. Returns true (1) on
-  /// success.
-  ///
-  int(CEF_CALLBACK* set_enabled_at)(struct _cef_menu_model_t* self,
-                                    size_t index,
-                                    int enabled);
-
-  ///
-  /// Returns true (1) if the specified |command_id| is checked. Only applies to
-  /// check and radio items.
-  ///
-  int(CEF_CALLBACK* is_checked)(struct _cef_menu_model_t* self, int command_id);
-
-  ///
-  /// Returns true (1) if the specified |index| is checked. Only applies to
-  /// check and radio items.
-  ///
-  int(CEF_CALLBACK* is_checked_at)(struct _cef_menu_model_t* self,
-                                   size_t index);
-
-  ///
-  /// Check the specified |command_id|. Only applies to check and radio items.
-  /// Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_checked)(struct _cef_menu_model_t* self,
-                                 int command_id,
-                                 int checked);
-
-  ///
-  /// Check the specified |index|. Only applies to check and radio items.
-  /// Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_checked_at)(struct _cef_menu_model_t* self,
-                                    size_t index,
-                                    int checked);
-
-  ///
-  /// Returns true (1) if the specified |command_id| has a keyboard accelerator
-  /// assigned.
-  ///
-  int(CEF_CALLBACK* has_accelerator)(struct _cef_menu_model_t* self,
-                                     int command_id);
-
-  ///
-  /// Returns true (1) if the specified |index| has a keyboard accelerator
-  /// assigned.
-  ///
-  int(CEF_CALLBACK* has_accelerator_at)(struct _cef_menu_model_t* self,
-                                        size_t index);
-
-  ///
-  /// Set the keyboard accelerator for the specified |command_id|. |key_code|
-  /// can be any virtual key or character value. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_accelerator)(struct _cef_menu_model_t* self,
-                                     int command_id,
-                                     int key_code,
-                                     int shift_pressed,
-                                     int ctrl_pressed,
-                                     int alt_pressed);
-
-  ///
-  /// Set the keyboard accelerator at the specified |index|. |key_code| can be
-  /// any virtual key or character value. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_accelerator_at)(struct _cef_menu_model_t* self,
-                                        size_t index,
-                                        int key_code,
-                                        int shift_pressed,
-                                        int ctrl_pressed,
-                                        int alt_pressed);
-
-  ///
-  /// Remove the keyboard accelerator for the specified |command_id|. Returns
-  /// true (1) on success.
-  ///
-  int(CEF_CALLBACK* remove_accelerator)(struct _cef_menu_model_t* self,
-                                        int command_id);
-
-  ///
-  /// Remove the keyboard accelerator at the specified |index|. Returns true (1)
-  /// on success.
-  ///
-  int(CEF_CALLBACK* remove_accelerator_at)(struct _cef_menu_model_t* self,
-                                           size_t index);
-
-  ///
-  /// Retrieves the keyboard accelerator for the specified |command_id|. Returns
-  /// true (1) on success.
-  ///
-  int(CEF_CALLBACK* get_accelerator)(struct _cef_menu_model_t* self,
-                                     int command_id,
-                                     int* key_code,
-                                     int* shift_pressed,
-                                     int* ctrl_pressed,
-                                     int* alt_pressed);
-
-  ///
-  /// Retrieves the keyboard accelerator for the specified |index|. Returns true
-  /// (1) on success.
-  ///
-  int(CEF_CALLBACK* get_accelerator_at)(struct _cef_menu_model_t* self,
-                                        size_t index,
-                                        int* key_code,
-                                        int* shift_pressed,
-                                        int* ctrl_pressed,
-                                        int* alt_pressed);
-
-  ///
-  /// Set the explicit color for |command_id| and |color_type| to |color|.
-  /// Specify a |color| value of 0 to remove the explicit color. If no explicit
-  /// color or default color is set for |color_type| then the system color will
-  /// be used. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_color)(struct _cef_menu_model_t* self,
-                               int command_id,
-                               cef_menu_color_type_t color_type,
-                               cef_color_t color);
-
-  ///
-  /// Set the explicit color for |command_id| and |index| to |color|. Specify a
-  /// |color| value of 0 to remove the explicit color. Specify an |index| value
-  /// of -1 to set the default color for items that do not have an explicit
-  /// color set. If no explicit color or default color is set for |color_type|
-  /// then the system color will be used. Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* set_color_at)(struct _cef_menu_model_t* self,
-                                  int index,
-                                  cef_menu_color_type_t color_type,
-                                  cef_color_t color);
-
-  ///
-  /// Returns in |color| the color that was explicitly set for |command_id| and
-  /// |color_type|. If a color was not set then 0 will be returned in |color|.
-  /// Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* get_color)(struct _cef_menu_model_t* self,
-                               int command_id,
-                               cef_menu_color_type_t color_type,
-                               cef_color_t* color);
-
-  ///
-  /// Returns in |color| the color that was explicitly set for |command_id| and
-  /// |color_type|. Specify an |index| value of -1 to return the default color
-  /// in |color|. If a color was not set then 0 will be returned in |color|.
-  /// Returns true (1) on success.
-  ///
-  int(CEF_CALLBACK* get_color_at)(struct _cef_menu_model_t* self,
-                                  int index,
-                                  cef_menu_color_type_t color_type,
-                                  cef_color_t* color);
-
-  ///
-  /// Sets the font list for the specified |command_id|. If |font_list| is NULL
-  /// the system font will be used. Returns true (1) on success. The format is
-  /// "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where:
-  /// - FONT_FAMILY_LIST is a comma-separated list of font family names,
-  /// - STYLES is an optional space-separated list of style names (case-
-  ///   sensitive "Bold" and "Italic" are supported), and
-  /// - SIZE is an integer font size in pixels with the suffix "px".
-  ///
-  /// Here are examples of valid font description strings:
-  /// - "Arial, Helvetica, Bold Italic 14px"
-  /// - "Arial, 14px"
-  ///
-  int(CEF_CALLBACK* set_font_list)(struct _cef_menu_model_t* self,
-                                   int command_id,
-                                   const cef_string_t* font_list);
-
-  ///
-  /// Sets the font list for the specified |index|. Specify an |index| value of
-  /// - 1 to set the default font. If |font_list| is NULL the system font will
-  /// - FONT_FAMILY_LIST is a comma-separated list of font family names,
-  /// - STYLES is an optional space-separated list of style names (case-
-  ///   sensitive "Bold" and "Italic" are supported), and
-  /// - SIZE is an integer font size in pixels with the suffix "px".
-  ///
-  /// Here are examples of valid font description strings:
-  /// - "Arial, Helvetica, Bold Italic 14px"
-  /// - "Arial, 14px"
-  ///
-  int(CEF_CALLBACK* set_font_list_at)(struct _cef_menu_model_t* self,
-                                      int index,
-                                      const cef_string_t* font_list);
-} cef_menu_model_t;
-
-///
-/// Create a new MenuModel with the specified |delegate|.
-///
-CEF_EXPORT cef_menu_model_t* cef_menu_model_create(
-    struct _cef_menu_model_delegate_t* delegate);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_

include/capi/cef_menu_model_delegate_capi.h

@@ -1,123 +0,0 @@
-// 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=01bdeaf96ea01591689b52b0955504644d6614b8$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_menu_model_t;
-
-///
-/// Implement this structure to handle menu model events. The functions of this
-/// structure will be called on the browser process UI thread unless otherwise
-/// indicated.
-///
-typedef struct _cef_menu_model_delegate_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Perform the action associated with the specified |command_id| and optional
-  /// |event_flags|.
-  ///
-  void(CEF_CALLBACK* execute_command)(struct _cef_menu_model_delegate_t* self,
-                                      struct _cef_menu_model_t* menu_model,
-                                      int command_id,
-                                      cef_event_flags_t event_flags);
-
-  ///
-  /// Called when the user moves the mouse outside the menu and over the owning
-  /// window.
-  ///
-  void(CEF_CALLBACK* mouse_outside_menu)(
-      struct _cef_menu_model_delegate_t* self,
-      struct _cef_menu_model_t* menu_model,
-      const cef_point_t* screen_point);
-
-  ///
-  /// Called on unhandled open submenu keyboard commands. |is_rtl| will be true
-  /// (1) if the menu is displaying a right-to-left language.
-  ///
-  void(CEF_CALLBACK* unhandled_open_submenu)(
-      struct _cef_menu_model_delegate_t* self,
-      struct _cef_menu_model_t* menu_model,
-      int is_rtl);
-
-  ///
-  /// Called on unhandled close submenu keyboard commands. |is_rtl| will be true
-  /// (1) if the menu is displaying a right-to-left language.
-  ///
-  void(CEF_CALLBACK* unhandled_close_submenu)(
-      struct _cef_menu_model_delegate_t* self,
-      struct _cef_menu_model_t* menu_model,
-      int is_rtl);
-
-  ///
-  /// The menu is about to show.
-  ///
-  void(CEF_CALLBACK* menu_will_show)(struct _cef_menu_model_delegate_t* self,
-                                     struct _cef_menu_model_t* menu_model);
-
-  ///
-  /// The menu has closed.
-  ///
-  void(CEF_CALLBACK* menu_closed)(struct _cef_menu_model_delegate_t* self,
-                                  struct _cef_menu_model_t* menu_model);
-
-  ///
-  /// Optionally modify a menu item label. Return true (1) if |label| was
-  /// modified.
-  ///
-  int(CEF_CALLBACK* format_label)(struct _cef_menu_model_delegate_t* self,
-                                  struct _cef_menu_model_t* menu_model,
-                                  cef_string_t* label);
-} cef_menu_model_delegate_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_

include/capi/cef_navigation_entry_capi.h

@@ -1,133 +0,0 @@
-// 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=dbdac05f2ebd8e8a357eacfe5095676a5bd5b1ac$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_ssl_status_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure used to represent an entry in navigation history.
-///
-typedef struct _cef_navigation_entry_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* is_valid)(struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the actual URL of the page. For some pages this may be data: URL
-  /// or similar. Use get_display_url() to return a display-friendly version.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_url)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns a display-friendly version of the URL.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_display_url)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the original URL that was entered by the user before any
-  /// redirects.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_original_url)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the title set by the page. This value may be NULL.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_title)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the transition type which indicates what the user did to move to
-  /// this page from the previous page.
-  ///
-  cef_transition_type_t(CEF_CALLBACK* get_transition_type)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns true (1) if this navigation includes post data.
-  ///
-  int(CEF_CALLBACK* has_post_data)(struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the time for the last known successful navigation completion. A
-  /// navigation may be completed more than once if the page is reloaded. May be
-  /// 0 if the navigation has not yet completed.
-  ///
-  cef_basetime_t(CEF_CALLBACK* get_completion_time)(
-      struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the HTTP status code for the last known successful navigation
-  /// response. May be 0 if the response has not yet been received or if the
-  /// navigation has not yet completed.
-  ///
-  int(CEF_CALLBACK* get_http_status_code)(struct _cef_navigation_entry_t* self);
-
-  ///
-  /// Returns the SSL information for this navigation entry.
-  ///
-  struct _cef_sslstatus_t*(CEF_CALLBACK* get_sslstatus)(
-      struct _cef_navigation_entry_t* self);
-} cef_navigation_entry_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_

include/capi/cef_origin_whitelist_capi.h

@@ -1,112 +0,0 @@
-// 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=f146fd9172033e77e90994841df9fa55ff71aa4b$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Add an entry to the cross-origin access whitelist.
-///
-/// The same-origin policy restricts how scripts hosted from different origins
-/// (scheme + domain + port) can communicate. By default, scripts can only
-/// access resources with the same origin. Scripts hosted on the HTTP and HTTPS
-/// schemes (but no other schemes) can use the "Access-Control-Allow-Origin"
-/// header to allow cross-origin requests. For example,
-/// https://source.example.com can make XMLHttpRequest requests on
-/// http://target.example.com if the http://target.example.com request returns
-/// an "Access-Control-Allow-Origin: https://source.example.com" response
-/// header.
-///
-/// Scripts in separate frames or iframes and hosted from the same protocol and
-/// domain suffix can execute cross-origin JavaScript if both pages set the
-/// document.domain value to the same domain suffix. For example,
-/// scheme://foo.example.com and scheme://bar.example.com can communicate using
-/// JavaScript if both domains set document.domain="example.com".
-///
-/// This function is used to allow access to origins that would otherwise
-/// violate the same-origin policy. Scripts hosted underneath the fully
-/// qualified |source_origin| URL (like http://www.example.com) will be allowed
-/// access to all resources hosted on the specified |target_protocol| and
-/// |target_domain|. If |target_domain| is non-NULL and
-/// |allow_target_subdomains| is false (0) only exact domain matches will be
-/// allowed. If |target_domain| contains a top- level domain component (like
-/// "example.com") and |allow_target_subdomains| is true (1) sub-domain matches
-/// will be allowed. If |target_domain| is NULL and |allow_target_subdomains| if
-/// true (1) all domains and IP addresses will be allowed.
-///
-/// This function cannot be used to bypass the restrictions on local or display
-/// isolated schemes. See the comments on CefRegisterCustomScheme for more
-/// information.
-///
-/// This function may be called on any thread. Returns false (0) if
-/// |source_origin| is invalid or the whitelist cannot be accessed.
-///
-CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
-    const cef_string_t* source_origin,
-    const cef_string_t* target_protocol,
-    const cef_string_t* target_domain,
-    int allow_target_subdomains);
-
-///
-/// Remove an entry from the cross-origin access whitelist. Returns false (0) if
-/// |source_origin| is invalid or the whitelist cannot be accessed.
-///
-CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
-    const cef_string_t* source_origin,
-    const cef_string_t* target_protocol,
-    const cef_string_t* target_domain,
-    int allow_target_subdomains);
-
-///
-/// Remove all entries from the cross-origin access whitelist. Returns false (0)
-/// if the whitelist cannot be accessed.
-///
-CEF_EXPORT int cef_clear_cross_origin_whitelist(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_

include/capi/cef_parser_capi.h

@@ -1,184 +0,0 @@
-// 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=8accded29b97df1549e86e58d8976fe0f800359a$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Combines specified |base_url| and |relative_url| into |resolved_url|.
-/// Returns false (0) if one of the URLs is NULL or invalid.
-///
-CEF_EXPORT int cef_resolve_url(const cef_string_t* base_url,
-                               const cef_string_t* relative_url,
-                               cef_string_t* resolved_url);
-
-///
-/// Parse the specified |url| into its component parts. Returns false (0) if the
-/// URL is NULL or invalid.
-///
-CEF_EXPORT int cef_parse_url(const cef_string_t* url,
-                             struct _cef_urlparts_t* parts);
-
-///
-/// Creates a URL from the specified |parts|, which must contain a non-NULL spec
-/// or a non-NULL host and path (at a minimum), but not both. Returns false (0)
-/// if |parts| isn't initialized as described.
-///
-CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts,
-                              cef_string_t* url);
-
-///
-/// This is a convenience function for formatting a URL in a concise and human-
-/// friendly way to help users make security-related decisions (or in other
-/// circumstances when people need to distinguish sites, origins, or otherwise-
-/// simplified URLs from each other). Internationalized domain names (IDN) may
-/// be presented in Unicode if the conversion is considered safe. The returned
-/// value will (a) omit the path for standard schemes, excepting file and
-/// filesystem, and (b) omit the port if it is the default for the scheme. Do
-/// not use this for URLs which will be parsed or sent to other applications.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t
-cef_format_url_for_security_display(const cef_string_t* origin_url);
-
-///
-/// Returns the mime type for the specified file extension or an NULL string if
-/// unknown.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t
-cef_get_mime_type(const cef_string_t* extension);
-
-///
-/// Get the extensions associated with the given mime type. This should be
-/// passed in lower case. There could be multiple extensions for a given mime
-/// type, like "html,htm" for "text/html", or "txt,text,html,..." for "text/*".
-/// Any existing elements in the provided vector will not be erased.
-///
-CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type,
-                                                 cef_string_list_t extensions);
-
-///
-/// Encodes |data| as a base64 string.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data,
-                                                  size_t data_size);
-
-///
-/// Decodes the base64 encoded string |data|. The returned value will be NULL if
-/// the decoding fails.
-///
-CEF_EXPORT struct _cef_binary_value_t* cef_base64decode(
-    const cef_string_t* data);
-
-///
-/// Escapes characters in |text| which are unsuitable for use as a query
-/// parameter value. Everything except alphanumerics and -_.!~*'() will be
-/// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The
-/// result is basically the same as encodeURIComponent in Javacript.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text,
-                                               int use_plus);
-
-///
-/// Unescapes |text| and returns the result. Unescaping consists of looking for
-/// the exact pattern "%XX" where each X is a hex digit and converting to the
-/// character with the numerical value of those digits (e.g. "i%20=%203%3b"
-/// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will
-/// attempt to interpret the initial decoded result as UTF-8. If the result is
-/// convertable into UTF-8 it will be returned as converted. Otherwise the
-/// initial decoded result will be returned.  The |unescape_rule| parameter
-/// supports further customization the decoding process.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t
-cef_uridecode(const cef_string_t* text,
-              int convert_to_utf8,
-              cef_uri_unescape_rule_t unescape_rule);
-
-///
-/// Parses the specified |json_string| and returns a dictionary or list
-/// representation. If JSON parsing fails this function returns NULL.
-///
-CEF_EXPORT struct _cef_value_t* cef_parse_json(
-    const cef_string_t* json_string,
-    cef_json_parser_options_t options);
-
-///
-/// Parses the specified UTF8-encoded |json| buffer of size |json_size| and
-/// returns a dictionary or list representation. If JSON parsing fails this
-/// function returns NULL.
-///
-CEF_EXPORT struct _cef_value_t* cef_parse_json_buffer(
-    const void* json,
-    size_t json_size,
-    cef_json_parser_options_t options);
-
-///
-/// Parses the specified |json_string| and returns a dictionary or list
-/// representation. If JSON parsing fails this function returns NULL and
-/// populates |error_msg_out| with a formatted error message.
-///
-CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
-    const cef_string_t* json_string,
-    cef_json_parser_options_t options,
-    cef_string_t* error_msg_out);
-
-///
-/// Generates a JSON string from the specified root |node| which should be a
-/// dictionary or list value. Returns an NULL string on failure. This function
-/// requires exclusive access to |node| including any underlying data.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t
-cef_write_json(struct _cef_value_t* node, cef_json_writer_options_t options);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_

include/capi/cef_path_util_capi.h

@@ -1,59 +0,0 @@
-// 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=ee0c50b4e1f51fb2286da24bb9244ae74f3b0c6f$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Retrieve the path associated with the specified |key|. Returns true (1) on
-/// success. Can be called on any thread in the browser process.
-///
-CEF_EXPORT int cef_get_path(cef_path_key_t key, cef_string_t* path);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_

include/capi/cef_permission_handler_capi.h

@@ -1,164 +0,0 @@
-// 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=c9b3913701581cd6a1077fa3a39d197f338a2507$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure used for asynchronous continuation of media access
-/// permission requests.
-///
-typedef struct _cef_media_access_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Call to allow or deny media access. If this callback was initiated in
-  /// response to a getUserMedia (indicated by
-  /// CEF_MEDIA_PERMISSION_DEVICE_AUDIO_CAPTURE and/or
-  /// CEF_MEDIA_PERMISSION_DEVICE_VIDEO_CAPTURE being set) then
-  /// |allowed_permissions| must match |required_permissions| passed to
-  /// OnRequestMediaAccessPermission.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_media_access_callback_t* self,
-                           uint32_t allowed_permissions);
-
-  ///
-  /// Cancel the media access request.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_media_access_callback_t* self);
-} cef_media_access_callback_t;
-
-///
-/// Callback structure used for asynchronous continuation of permission prompts.
-///
-typedef struct _cef_permission_prompt_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Complete the permissions request with the specified |result|.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_permission_prompt_callback_t* self,
-                           cef_permission_request_result_t result);
-} cef_permission_prompt_callback_t;
-
-///
-/// Implement this structure to handle events related to permission requests.
-/// The functions of this structure will be called on the browser process UI
-/// thread.
-///
-typedef struct _cef_permission_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called when a page requests permission to access media.
-  /// |requesting_origin| is the URL origin requesting permission.
-  /// |requested_permissions| is a combination of values from
-  /// cef_media_access_permission_types_t that represent the requested
-  /// permissions. Return true (1) and call cef_media_access_callback_t
-  /// functions either in this function or at a later time to continue or cancel
-  /// the request. Return false (0) to proceed with default handling. With the
-  /// Chrome runtime, default handling will display the permission request UI.
-  /// With the Alloy runtime, default handling will deny the request. This
-  /// function will not be called if the "--enable-media-stream" command-line
-  /// switch is used to grant all permissions.
-  ///
-  int(CEF_CALLBACK* on_request_media_access_permission)(
-      struct _cef_permission_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      const cef_string_t* requesting_origin,
-      uint32_t requested_permissions,
-      struct _cef_media_access_callback_t* callback);
-
-  ///
-  /// Called when a page should show a permission prompt. |prompt_id| uniquely
-  /// identifies the prompt. |requesting_origin| is the URL origin requesting
-  /// permission. |requested_permissions| is a combination of values from
-  /// cef_permission_request_types_t that represent the requested permissions.
-  /// Return true (1) and call cef_permission_prompt_callback_t::Continue either
-  /// in this function or at a later time to continue or cancel the request.
-  /// Return false (0) to proceed with default handling. With the Chrome
-  /// runtime, default handling will display the permission prompt UI. With the
-  /// Alloy runtime, default handling is CEF_PERMISSION_RESULT_IGNORE.
-  ///
-  int(CEF_CALLBACK* on_show_permission_prompt)(
-      struct _cef_permission_handler_t* self,
-      struct _cef_browser_t* browser,
-      uint64_t prompt_id,
-      const cef_string_t* requesting_origin,
-      uint32_t requested_permissions,
-      struct _cef_permission_prompt_callback_t* callback);
-
-  ///
-  /// Called when a permission prompt handled via OnShowPermissionPrompt is
-  /// dismissed. |prompt_id| will match the value that was passed to
-  /// OnShowPermissionPrompt. |result| will be the value passed to
-  /// cef_permission_prompt_callback_t::Continue or CEF_PERMISSION_RESULT_IGNORE
-  /// if the dialog was dismissed for other reasons such as navigation, browser
-  /// closure, etc. This function will not be called if OnShowPermissionPrompt
-  /// returned false (0) for |prompt_id|.
-  ///
-  void(CEF_CALLBACK* on_dismiss_permission_prompt)(
-      struct _cef_permission_handler_t* self,
-      struct _cef_browser_t* browser,
-      uint64_t prompt_id,
-      cef_permission_request_result_t result);
-} cef_permission_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PERMISSION_HANDLER_CAPI_H_

include/capi/cef_preference_capi.h

@@ -1,148 +0,0 @@
-// 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=1c0e469a283538945834404bcd5934b9bb9a0756$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure that manages custom preference registrations.
-///
-typedef struct _cef_preference_registrar_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_scoped_t base;
-
-  ///
-  /// Register a preference with the specified |name| and |default_value|. To
-  /// avoid conflicts with built-in preferences the |name| value should contain
-  /// an application-specific prefix followed by a period (e.g. "myapp.value").
-  /// The contents of |default_value| will be copied. The data type for the
-  /// preference will be inferred from |default_value|'s type and cannot be
-  /// changed after registration. Returns true (1) on success. Returns false (0)
-  /// if |name| is already registered or if |default_value| has an invalid type.
-  /// This function must be called from within the scope of the
-  /// cef_browser_process_handler_t::OnRegisterCustomPreferences callback.
-  ///
-  int(CEF_CALLBACK* add_preference)(struct _cef_preference_registrar_t* self,
-                                    const cef_string_t* name,
-                                    struct _cef_value_t* default_value);
-} cef_preference_registrar_t;
-
-///
-/// Manage access to preferences. Many built-in preferences are registered by
-/// Chromium. Custom preferences can be registered in
-/// cef_browser_process_handler_t::OnRegisterCustomPreferences.
-///
-typedef struct _cef_preference_manager_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if a preference with the specified |name| exists. This
-  /// function must be called on the browser process UI thread.
-  ///
-  int(CEF_CALLBACK* has_preference)(struct _cef_preference_manager_t* self,
-                                    const cef_string_t* name);
-
-  ///
-  /// Returns the value for the preference with the specified |name|. Returns
-  /// NULL if the preference does not exist. The returned object contains a copy
-  /// of the underlying preference value and modifications to the returned
-  /// object will not modify the underlying preference value. This function must
-  /// be called on the browser process UI thread.
-  ///
-  struct _cef_value_t*(CEF_CALLBACK* get_preference)(
-      struct _cef_preference_manager_t* self,
-      const cef_string_t* name);
-
-  ///
-  /// Returns all preferences as a dictionary. If |include_defaults| is true (1)
-  /// then preferences currently at their default value will be included. The
-  /// returned object contains a copy of the underlying preference values and
-  /// modifications to the returned object will not modify the underlying
-  /// preference values. This function must be called on the browser process UI
-  /// thread.
-  ///
-  struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)(
-      struct _cef_preference_manager_t* self,
-      int include_defaults);
-
-  ///
-  /// Returns true (1) if the preference with the specified |name| can be
-  /// modified using SetPreference. As one example preferences set via the
-  /// command-line usually cannot be modified. This function must be called on
-  /// the browser process UI thread.
-  ///
-  int(CEF_CALLBACK* can_set_preference)(struct _cef_preference_manager_t* self,
-                                        const cef_string_t* name);
-
-  ///
-  /// Set the |value| associated with preference |name|. Returns true (1) if the
-  /// value is set successfully and false (0) otherwise. If |value| is NULL the
-  /// preference will be restored to its default value. If setting the
-  /// preference fails then |error| will be populated with a detailed
-  /// description of the problem. This function must be called on the browser
-  /// process UI thread.
-  ///
-  int(CEF_CALLBACK* set_preference)(struct _cef_preference_manager_t* self,
-                                    const cef_string_t* name,
-                                    struct _cef_value_t* value,
-                                    cef_string_t* error);
-} cef_preference_manager_t;
-
-///
-/// Returns the global preference manager object.
-///
-CEF_EXPORT cef_preference_manager_t* cef_preference_manager_get_global(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PREFERENCE_CAPI_H_

include/capi/cef_preference_manager_capi.h

@@ -1,116 +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=1f5dd49cfc5aeb4b673c10750de01768f5cd2694$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Manage access to preferences.
-///
-typedef struct _cef_preference_manager_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if a preference with the specified |name| exists. This
-  /// function must be called on the browser process UI thread.
-  ///
-  int(CEF_CALLBACK* has_preference)(struct _cef_preference_manager_t* self,
-                                    const cef_string_t* name);
-
-  ///
-  /// Returns the value for the preference with the specified |name|. Returns
-  /// NULL if the preference does not exist. The returned object contains a copy
-  /// of the underlying preference value and modifications to the returned
-  /// object will not modify the underlying preference value. This function must
-  /// be called on the browser process UI thread.
-  ///
-  struct _cef_value_t*(CEF_CALLBACK* get_preference)(
-      struct _cef_preference_manager_t* self,
-      const cef_string_t* name);
-
-  ///
-  /// Returns all preferences as a dictionary. If |include_defaults| is true (1)
-  /// then preferences currently at their default value will be included. The
-  /// returned object contains a copy of the underlying preference values and
-  /// modifications to the returned object will not modify the underlying
-  /// preference values. This function must be called on the browser process UI
-  /// thread.
-  ///
-  struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)(
-      struct _cef_preference_manager_t* self,
-      int include_defaults);
-
-  ///
-  /// Returns true (1) if the preference with the specified |name| can be
-  /// modified using SetPreference. As one example preferences set via the
-  /// command-line usually cannot be modified. This function must be called on
-  /// the browser process UI thread.
-  ///
-  int(CEF_CALLBACK* can_set_preference)(struct _cef_preference_manager_t* self,
-                                        const cef_string_t* name);
-
-  ///
-  /// Set the |value| associated with preference |name|. Returns true (1) if the
-  /// value is set successfully and false (0) otherwise. If |value| is NULL the
-  /// preference will be restored to its default value. If setting the
-  /// preference fails then |error| will be populated with a detailed
-  /// description of the problem. This function must be called on the browser
-  /// process UI thread.
-  ///
-  int(CEF_CALLBACK* set_preference)(struct _cef_preference_manager_t* self,
-                                    const cef_string_t* name,
-                                    struct _cef_value_t* value,
-                                    cef_string_t* error);
-} cef_preference_manager_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PREFERENCE_MANAGER_CAPI_H_

include/capi/cef_print_handler_capi.h

@@ -1,160 +0,0 @@
-// 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=96d5b6c0dc8f2575e686fb79684c63787cdfe876$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_print_settings_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure for asynchronous continuation of print dialog requests.
-///
-typedef struct _cef_print_dialog_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Continue printing with the specified |settings|.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_print_dialog_callback_t* self,
-                           struct _cef_print_settings_t* settings);
-
-  ///
-  /// Cancel the printing.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_print_dialog_callback_t* self);
-} cef_print_dialog_callback_t;
-
-///
-/// Callback structure for asynchronous continuation of print job requests.
-///
-typedef struct _cef_print_job_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Indicate completion of the print job.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_print_job_callback_t* self);
-} cef_print_job_callback_t;
-
-///
-/// Implement this structure to handle printing on Linux. Each browser will have
-/// only one print job in progress at a time. The functions of this structure
-/// will be called on the browser process UI thread.
-///
-typedef struct _cef_print_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called when printing has started for the specified |browser|. This
-  /// function will be called before the other OnPrint*() functions and
-  /// irrespective of how printing was initiated (e.g.
-  /// cef_browser_host_t::print(), JavaScript window.print() or PDF extension
-  /// print button).
-  ///
-  void(CEF_CALLBACK* on_print_start)(struct _cef_print_handler_t* self,
-                                     struct _cef_browser_t* browser);
-
-  ///
-  /// Synchronize |settings| with client state. If |get_defaults| is true (1)
-  /// then populate |settings| with the default print settings. Do not keep a
-  /// reference to |settings| outside of this callback.
-  ///
-  void(CEF_CALLBACK* on_print_settings)(struct _cef_print_handler_t* self,
-                                        struct _cef_browser_t* browser,
-                                        struct _cef_print_settings_t* settings,
-                                        int get_defaults);
-
-  ///
-  /// Show the print dialog. Execute |callback| once the dialog is dismissed.
-  /// Return true (1) if the dialog will be displayed or false (0) to cancel the
-  /// printing immediately.
-  ///
-  int(CEF_CALLBACK* on_print_dialog)(
-      struct _cef_print_handler_t* self,
-      struct _cef_browser_t* browser,
-      int has_selection,
-      struct _cef_print_dialog_callback_t* callback);
-
-  ///
-  /// Send the print job to the printer. Execute |callback| once the job is
-  /// completed. Return true (1) if the job will proceed or false (0) to cancel
-  /// the job immediately.
-  ///
-  int(CEF_CALLBACK* on_print_job)(struct _cef_print_handler_t* self,
-                                  struct _cef_browser_t* browser,
-                                  const cef_string_t* document_name,
-                                  const cef_string_t* pdf_file_path,
-                                  struct _cef_print_job_callback_t* callback);
-
-  ///
-  /// Reset client state related to printing.
-  ///
-  void(CEF_CALLBACK* on_print_reset)(struct _cef_print_handler_t* self,
-                                     struct _cef_browser_t* browser);
-
-  ///
-  /// Return the PDF paper size in device units. Used in combination with
-  /// cef_browser_host_t::print_to_pdf().
-  ///
-  cef_size_t(CEF_CALLBACK* get_pdf_paper_size)(
-      struct _cef_print_handler_t* self,
-      struct _cef_browser_t* browser,
-      int device_units_per_inch);
-} cef_print_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_

include/capi/cef_print_settings_capi.h

@@ -1,202 +0,0 @@
-// 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=63977fcbe4567db202914f69539f49b254352053$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure representing print settings.
-///
-typedef struct _cef_print_settings_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* is_valid)(struct _cef_print_settings_t* self);
-
-  ///
-  /// 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_print_settings_t* self);
-
-  ///
-  /// Set the page orientation.
-  ///
-  void(CEF_CALLBACK* set_orientation)(struct _cef_print_settings_t* self,
-                                      int landscape);
-
-  ///
-  /// Returns true (1) if the orientation is landscape.
-  ///
-  int(CEF_CALLBACK* is_landscape)(struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the printer printable area in device units. Some platforms already
-  /// provide flipped area. Set |landscape_needs_flip| to false (0) on those
-  /// platforms to avoid double flipping.
-  ///
-  void(CEF_CALLBACK* set_printer_printable_area)(
-      struct _cef_print_settings_t* self,
-      const cef_size_t* physical_size_device_units,
-      const cef_rect_t* printable_area_device_units,
-      int landscape_needs_flip);
-
-  ///
-  /// Set the device name.
-  ///
-  void(CEF_CALLBACK* set_device_name)(struct _cef_print_settings_t* self,
-                                      const cef_string_t* name);
-
-  ///
-  /// Get the device name.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_device_name)(
-      struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the DPI (dots per inch).
-  ///
-  void(CEF_CALLBACK* set_dpi)(struct _cef_print_settings_t* self, int dpi);
-
-  ///
-  /// Get the DPI (dots per inch).
-  ///
-  int(CEF_CALLBACK* get_dpi)(struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the page ranges.
-  ///
-  void(CEF_CALLBACK* set_page_ranges)(struct _cef_print_settings_t* self,
-                                      size_t rangesCount,
-                                      cef_range_t const* ranges);
-
-  ///
-  /// Returns the number of page ranges that currently exist.
-  ///
-  size_t(CEF_CALLBACK* get_page_ranges_count)(
-      struct _cef_print_settings_t* self);
-
-  ///
-  /// Retrieve the page ranges.
-  ///
-  void(CEF_CALLBACK* get_page_ranges)(struct _cef_print_settings_t* self,
-                                      size_t* rangesCount,
-                                      cef_range_t* ranges);
-
-  ///
-  /// Set whether only the selection will be printed.
-  ///
-  void(CEF_CALLBACK* set_selection_only)(struct _cef_print_settings_t* self,
-                                         int selection_only);
-
-  ///
-  /// Returns true (1) if only the selection will be printed.
-  ///
-  int(CEF_CALLBACK* is_selection_only)(struct _cef_print_settings_t* self);
-
-  ///
-  /// Set whether pages will be collated.
-  ///
-  void(CEF_CALLBACK* set_collate)(struct _cef_print_settings_t* self,
-                                  int collate);
-
-  ///
-  /// Returns true (1) if pages will be collated.
-  ///
-  int(CEF_CALLBACK* will_collate)(struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the color model.
-  ///
-  void(CEF_CALLBACK* set_color_model)(struct _cef_print_settings_t* self,
-                                      cef_color_model_t model);
-
-  ///
-  /// Get the color model.
-  ///
-  cef_color_model_t(CEF_CALLBACK* get_color_model)(
-      struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the number of copies.
-  ///
-  void(CEF_CALLBACK* set_copies)(struct _cef_print_settings_t* self,
-                                 int copies);
-
-  ///
-  /// Get the number of copies.
-  ///
-  int(CEF_CALLBACK* get_copies)(struct _cef_print_settings_t* self);
-
-  ///
-  /// Set the duplex mode.
-  ///
-  void(CEF_CALLBACK* set_duplex_mode)(struct _cef_print_settings_t* self,
-                                      cef_duplex_mode_t mode);
-
-  ///
-  /// Get the duplex mode.
-  ///
-  cef_duplex_mode_t(CEF_CALLBACK* get_duplex_mode)(
-      struct _cef_print_settings_t* self);
-} cef_print_settings_t;
-
-///
-/// Create a new cef_print_settings_t object.
-///
-CEF_EXPORT cef_print_settings_t* cef_print_settings_create(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_

include/capi/cef_process_message_capi.h

@@ -1,111 +0,0 @@
-// 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=89c569df7e5e4a6035d4527218ce4dc1d68e20f0$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_shared_memory_region_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure representing a message. Can be used on any process and thread.
-///
-typedef struct _cef_process_message_t {
-  ///
-  /// 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).
-  ///
-  int(CEF_CALLBACK* is_valid)(struct _cef_process_message_t* self);
-
-  ///
-  /// 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_process_message_t* self);
-
-  ///
-  /// Returns a writable copy of this object. Returns nullptr when message
-  /// contains a shared memory region.
-  ///
-  struct _cef_process_message_t*(CEF_CALLBACK* copy)(
-      struct _cef_process_message_t* self);
-
-  ///
-  /// Returns the message name.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_name)(
-      struct _cef_process_message_t* self);
-
-  ///
-  /// Returns the list of arguments. Returns nullptr when message contains a
-  /// shared memory region.
-  ///
-  struct _cef_list_value_t*(CEF_CALLBACK* get_argument_list)(
-      struct _cef_process_message_t* self);
-
-  ///
-  /// Returns the shared memory region. Returns nullptr when message contains an
-  /// argument list.
-  ///
-  struct _cef_shared_memory_region_t*(CEF_CALLBACK* get_shared_memory_region)(
-      struct _cef_process_message_t* self);
-} cef_process_message_t;
-
-///
-/// Create a new cef_process_message_t object with the specified name.
-///
-CEF_EXPORT cef_process_message_t* cef_process_message_create(
-    const cef_string_t* name);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_

include/capi/cef_process_util_capi.h

@@ -1,65 +0,0 @@
-// 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=a61a639c7e53ecd9481eae363bac557055f0442e$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Launches the process specified via |command_line|. Returns true (1) upon
-/// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
-///
-/// Unix-specific notes:
-/// - All file descriptors open in the parent process will be closed in the
-///   child process except for stdin, stdout, and stderr.
-/// - If the first argument on the command line does not contain a slash, PATH
-///   will be searched. (See man execvp.)
-///
-CEF_EXPORT int cef_launch_process(struct _cef_command_line_t* command_line);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_

include/capi/cef_registration_capi.h

@@ -1,63 +0,0 @@
-// 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=c53a67bbf1497a51766bf03040714b5edb2117d5$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Generic callback structure used for managing the lifespan of a registration.
-///
-typedef struct _cef_registration_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-} cef_registration_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_

include/capi/cef_render_handler_capi.h

@@ -1,271 +0,0 @@
-// 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=5151b6ea3c06e46a75f2cd7679044a2891063d29$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_accessibility_handler_capi.h"
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_drag_data_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Implement this structure to handle events when window rendering is disabled.
-/// The functions of this structure will be called on the UI thread.
-///
-typedef struct _cef_render_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Return the handler for accessibility notifications. If no handler is
-  /// provided the default implementation will be used.
-  ///
-  struct _cef_accessibility_handler_t*(CEF_CALLBACK* get_accessibility_handler)(
-      struct _cef_render_handler_t* self);
-
-  ///
-  /// Called to retrieve the root window rectangle in screen DIP coordinates.
-  /// Return true (1) if the rectangle was provided. If this function returns
-  /// false (0) the rectangle from GetViewRect will be used.
-  ///
-  int(CEF_CALLBACK* get_root_screen_rect)(struct _cef_render_handler_t* self,
-                                          struct _cef_browser_t* browser,
-                                          cef_rect_t* rect);
-
-  ///
-  /// Called to retrieve the view rectangle in screen DIP coordinates. This
-  /// function must always provide a non-NULL rectangle.
-  ///
-  void(CEF_CALLBACK* get_view_rect)(struct _cef_render_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    cef_rect_t* rect);
-
-  ///
-  /// Called to retrieve the translation from view DIP coordinates to screen
-  /// coordinates. Windows/Linux should provide screen device (pixel)
-  /// coordinates and MacOS should provide screen DIP coordinates. Return true
-  /// (1) if the requested coordinates were provided.
-  ///
-  int(CEF_CALLBACK* get_screen_point)(struct _cef_render_handler_t* self,
-                                      struct _cef_browser_t* browser,
-                                      int viewX,
-                                      int viewY,
-                                      int* screenX,
-                                      int* screenY);
-
-  ///
-  /// Called to allow the client to fill in the CefScreenInfo object with
-  /// appropriate values. Return true (1) if the |screen_info| structure has
-  /// been modified.
-  ///
-  /// If the screen info rectangle is left NULL the rectangle from GetViewRect
-  /// will be used. If the rectangle is still NULL or invalid popups may not be
-  /// drawn correctly.
-  ///
-  int(CEF_CALLBACK* get_screen_info)(struct _cef_render_handler_t* self,
-                                     struct _cef_browser_t* browser,
-                                     cef_screen_info_t* screen_info);
-
-  ///
-  /// Called when the browser wants to show or hide the popup widget. The popup
-  /// should be shown if |show| is true (1) and hidden if |show| is false (0).
-  ///
-  void(CEF_CALLBACK* on_popup_show)(struct _cef_render_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    int show);
-
-  ///
-  /// Called when the browser wants to move or resize the popup widget. |rect|
-  /// contains the new location and size in view coordinates.
-  ///
-  void(CEF_CALLBACK* on_popup_size)(struct _cef_render_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    const cef_rect_t* rect);
-
-  ///
-  /// Called when an element should be painted. Pixel values passed to this
-  /// function are scaled relative to view coordinates based on the value of
-  /// CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
-  /// indicates whether the element is the view or the popup widget. |buffer|
-  /// contains the pixel data for the whole image. |dirtyRects| contains the set
-  /// of rectangles in pixel coordinates that need to be repainted. |buffer|
-  /// will be |width|*|height|*4 bytes in size and represents a BGRA image with
-  /// an upper-left origin. This function is only called when
-  /// cef_window_tInfo::shared_texture_enabled is set to false (0).
-  ///
-  void(CEF_CALLBACK* on_paint)(struct _cef_render_handler_t* self,
-                               struct _cef_browser_t* browser,
-                               cef_paint_element_type_t type,
-                               size_t dirtyRectsCount,
-                               cef_rect_t const* dirtyRects,
-                               const void* buffer,
-                               int width,
-                               int height);
-
-  ///
-  /// Called when an element has been rendered to the shared texture handle.
-  /// |type| indicates whether the element is the view or the popup widget.
-  /// |dirtyRects| contains the set of rectangles in pixel coordinates that need
-  /// to be repainted. |info| contains the shared handle; on Windows it is a
-  /// HANDLE to a texture that can be opened with D3D11 OpenSharedResource, on
-  /// macOS it is an IOSurface pointer that can be opened with Metal or OpenGL,
-  /// and on Linux it contains several planes, each with an fd to the underlying
-  /// system native buffer.
-  ///
-  /// The underlying implementation uses a pool to deliver frames. As a result,
-  /// the handle may differ every frame depending on how many frames are in-
-  /// progress. The handle's resource cannot be cached and cannot be accessed
-  /// outside of this callback. It should be reopened each time this callback is
-  /// executed and the contents should be copied to a texture owned by the
-  /// client application. The contents of |info| will be released back to the
-  /// pool after this callback returns.
-  ///
-  void(CEF_CALLBACK* on_accelerated_paint)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      cef_paint_element_type_t type,
-      size_t dirtyRectsCount,
-      cef_rect_t const* dirtyRects,
-      const cef_accelerated_paint_info_t* info);
-
-  ///
-  /// Called to retrieve the size of the touch handle for the specified
-  /// |orientation|.
-  ///
-  void(CEF_CALLBACK* get_touch_handle_size)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      cef_horizontal_alignment_t orientation,
-      cef_size_t* size);
-
-  ///
-  /// Called when touch handle state is updated. The client is responsible for
-  /// rendering the touch handles.
-  ///
-  void(CEF_CALLBACK* on_touch_handle_state_changed)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      const cef_touch_handle_state_t* state);
-
-  ///
-  /// Called when the user starts dragging content in the web view. Contextual
-  /// information about the dragged content is supplied by |drag_data|. (|x|,
-  /// |y|) is the drag start location in screen coordinates. OS APIs that run a
-  /// system message loop may be used within the StartDragging call.
-  ///
-  /// Return false (0) to abort the drag operation. Don't call any of
-  /// cef_browser_host_t::DragSource*Ended* functions after returning false (0).
-  ///
-  /// Return true (1) to handle the drag operation. Call
-  /// cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either
-  /// synchronously or asynchronously to inform the web view that the drag
-  /// operation has ended.
-  ///
-  int(CEF_CALLBACK* start_dragging)(struct _cef_render_handler_t* self,
-                                    struct _cef_browser_t* browser,
-                                    struct _cef_drag_data_t* drag_data,
-                                    cef_drag_operations_mask_t allowed_ops,
-                                    int x,
-                                    int y);
-
-  ///
-  /// Called when the web view wants to update the mouse cursor during a drag &
-  /// drop operation. |operation| describes the allowed operation (none, move,
-  /// copy, link).
-  ///
-  void(CEF_CALLBACK* update_drag_cursor)(struct _cef_render_handler_t* self,
-                                         struct _cef_browser_t* browser,
-                                         cef_drag_operations_mask_t operation);
-
-  ///
-  /// Called when the scroll offset has changed.
-  ///
-  void(CEF_CALLBACK* on_scroll_offset_changed)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      double x,
-      double y);
-
-  ///
-  /// Called when the IME composition range has changed. |selected_range| is the
-  /// range of characters that have been selected. |character_bounds| is the
-  /// bounds of each character in view coordinates.
-  ///
-  void(CEF_CALLBACK* on_ime_composition_range_changed)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      const cef_range_t* selected_range,
-      size_t character_boundsCount,
-      cef_rect_t const* character_bounds);
-
-  ///
-  /// Called when text selection has changed for the specified |browser|.
-  /// |selected_text| is the currently selected text and |selected_range| is the
-  /// character range.
-  ///
-  void(CEF_CALLBACK* on_text_selection_changed)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      const cef_string_t* selected_text,
-      const cef_range_t* selected_range);
-
-  ///
-  /// Called when an on-screen keyboard should be shown or hidden for the
-  /// specified |browser|. |input_mode| specifies what kind of keyboard should
-  /// be opened. If |input_mode| is CEF_TEXT_INPUT_MODE_NONE, any existing
-  /// keyboard for this browser should be hidden.
-  ///
-  void(CEF_CALLBACK* on_virtual_keyboard_requested)(
-      struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser,
-      cef_text_input_mode_t input_mode);
-} cef_render_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_

include/capi/cef_render_process_handler_capi.h

@@ -1,168 +0,0 @@
-// 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=6e2fccb5a8e49918d723f6c5223062cf98b0f9de$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_dom_capi.h"
-#include "include/capi/cef_frame_capi.h"
-#include "include/capi/cef_load_handler_capi.h"
-#include "include/capi/cef_process_message_capi.h"
-#include "include/capi/cef_v8_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure used to implement render process callbacks. The functions of this
-/// structure will be called on the render process main thread (TID_RENDERER)
-/// unless otherwise indicated.
-///
-typedef struct _cef_render_process_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called after WebKit has been initialized.
-  ///
-  void(CEF_CALLBACK* on_web_kit_initialized)(
-      struct _cef_render_process_handler_t* self);
-
-  ///
-  /// Called after a browser has been created. When browsing cross-origin a new
-  /// browser will be created before the old browser with the same identifier is
-  /// destroyed. |extra_info| is an optional read-only value originating from
-  /// cef_browser_host_t::cef_browser_host_create_browser(),
-  /// cef_browser_host_t::cef_browser_host_create_browser_sync(),
-  /// cef_life_span_handler_t::on_before_popup() or
-  /// cef_browser_view_t::cef_browser_view_create().
-  ///
-  void(CEF_CALLBACK* on_browser_created)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_dictionary_value_t* extra_info);
-
-  ///
-  /// Called before a browser is destroyed.
-  ///
-  void(CEF_CALLBACK* on_browser_destroyed)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser);
-
-  ///
-  /// Return the handler for browser load status events.
-  ///
-  struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)(
-      struct _cef_render_process_handler_t* self);
-
-  ///
-  /// Called immediately after the V8 context for a frame has been created. To
-  /// retrieve the JavaScript 'window' object use the
-  /// cef_v8context_t::get_global() function. V8 handles can only be accessed
-  /// from the thread on which they are created. A task runner for posting tasks
-  /// on the associated thread can be retrieved via the
-  /// cef_v8context_t::get_task_runner() function.
-  ///
-  void(CEF_CALLBACK* on_context_created)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_v8context_t* context);
-
-  ///
-  /// Called immediately before the V8 context for a frame is released. No
-  /// references to the context should be kept after this function is called.
-  ///
-  void(CEF_CALLBACK* on_context_released)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_v8context_t* context);
-
-  ///
-  /// Called for global uncaught exceptions in a frame. Execution of this
-  /// callback is disabled by default. To enable set
-  /// cef_settings_t.uncaught_exception_stack_size > 0.
-  ///
-  void(CEF_CALLBACK* on_uncaught_exception)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_v8context_t* context,
-      struct _cef_v8exception_t* exception,
-      struct _cef_v8stack_trace_t* stackTrace);
-
-  ///
-  /// Called when a new node in the the browser gets focus. The |node| value may
-  /// be NULL if no specific node has gained focus. The node 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* on_focused_node_changed)(
-      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_domnode_t* node);
-
-  ///
-  /// 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_render_process_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      cef_process_id_t source_process,
-      struct _cef_process_message_t* message);
-} cef_render_process_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_

include/capi/cef_request_capi.h

@@ -1,355 +0,0 @@
-// 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=14ce483864835eca476d08d39ed4236fbd1a874c$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_post_data_element_t;
-struct _cef_post_data_t;
-
-///
-/// Structure used to represent a web request. The functions of this structure
-/// may be called on any thread.
-///
-typedef struct _cef_request_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if this object is read-only.
-  ///
-  int(CEF_CALLBACK* is_read_only)(struct _cef_request_t* self);
-
-  ///
-  /// Get the fully qualified URL.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_request_t* self);
-
-  ///
-  /// Set the fully qualified URL.
-  ///
-  void(CEF_CALLBACK* set_url)(struct _cef_request_t* self,
-                              const cef_string_t* url);
-
-  ///
-  /// Get the request function type. The value will default to POST if post data
-  /// is provided and GET otherwise.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_method)(struct _cef_request_t* self);
-
-  ///
-  /// Set the request function type.
-  ///
-  void(CEF_CALLBACK* set_method)(struct _cef_request_t* self,
-                                 const cef_string_t* method);
-
-  ///
-  /// Set the referrer URL and policy. If non-NULL the referrer URL must be
-  /// fully qualified with an HTTP or HTTPS scheme component. Any username,
-  /// password or ref component will be removed.
-  ///
-  void(CEF_CALLBACK* set_referrer)(struct _cef_request_t* self,
-                                   const cef_string_t* referrer_url,
-                                   cef_referrer_policy_t policy);
-
-  ///
-  /// Get the referrer URL.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_referrer_url)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Get the referrer policy.
-  ///
-  cef_referrer_policy_t(CEF_CALLBACK* get_referrer_policy)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Get the post data.
-  ///
-  struct _cef_post_data_t*(CEF_CALLBACK* get_post_data)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Set the post data.
-  ///
-  void(CEF_CALLBACK* set_post_data)(struct _cef_request_t* self,
-                                    struct _cef_post_data_t* postData);
-
-  ///
-  /// Get the header values. Will not include the Referer value if any.
-  ///
-  void(CEF_CALLBACK* get_header_map)(struct _cef_request_t* self,
-                                     cef_string_multimap_t headerMap);
-
-  ///
-  /// Set the header values. If a Referer value exists in the header map it will
-  /// be removed and ignored.
-  ///
-  void(CEF_CALLBACK* set_header_map)(struct _cef_request_t* self,
-                                     cef_string_multimap_t headerMap);
-
-  ///
-  /// Returns the first header value for |name| or an NULL string if not found.
-  /// Will not return the Referer value if any. Use GetHeaderMap instead if
-  /// |name| might have multiple values.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_header_by_name)(
-      struct _cef_request_t* self,
-      const cef_string_t* name);
-
-  ///
-  /// Set the header |name| to |value|. If |overwrite| is true (1) any existing
-  /// values will be replaced with the new value. If |overwrite| is false (0)
-  /// any existing values will not be overwritten. The Referer value cannot be
-  /// set using this function.
-  ///
-  void(CEF_CALLBACK* set_header_by_name)(struct _cef_request_t* self,
-                                         const cef_string_t* name,
-                                         const cef_string_t* value,
-                                         int overwrite);
-
-  ///
-  /// Set all values at one time.
-  ///
-  void(CEF_CALLBACK* set)(struct _cef_request_t* self,
-                          const cef_string_t* url,
-                          const cef_string_t* method,
-                          struct _cef_post_data_t* postData,
-                          cef_string_multimap_t headerMap);
-
-  ///
-  /// Get the flags used in combination with cef_urlrequest_t. See
-  /// cef_urlrequest_flags_t for supported values.
-  ///
-  int(CEF_CALLBACK* get_flags)(struct _cef_request_t* self);
-
-  ///
-  /// Set the flags used in combination with cef_urlrequest_t.  See
-  /// cef_urlrequest_flags_t for supported values.
-  ///
-  void(CEF_CALLBACK* set_flags)(struct _cef_request_t* self, int flags);
-
-  ///
-  /// Get the URL to the first party for cookies used in combination with
-  /// cef_urlrequest_t.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_first_party_for_cookies)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Set the URL to the first party for cookies used in combination with
-  /// cef_urlrequest_t.
-  ///
-  void(CEF_CALLBACK* set_first_party_for_cookies)(struct _cef_request_t* self,
-                                                  const cef_string_t* url);
-
-  ///
-  /// Get the resource type for this request. Only available in the browser
-  /// process.
-  ///
-  cef_resource_type_t(CEF_CALLBACK* get_resource_type)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Get the transition type for this request. Only available in the browser
-  /// process and only applies to requests that represent a main frame or sub-
-  /// frame navigation.
-  ///
-  cef_transition_type_t(CEF_CALLBACK* get_transition_type)(
-      struct _cef_request_t* self);
-
-  ///
-  /// Returns the globally unique identifier for this request or 0 if not
-  /// specified. Can be used by cef_resource_request_handler_t implementations
-  /// in the browser process to track a single request across multiple
-  /// callbacks.
-  ///
-  uint64_t(CEF_CALLBACK* get_identifier)(struct _cef_request_t* self);
-} cef_request_t;
-
-///
-/// Create a new cef_request_t object.
-///
-CEF_EXPORT cef_request_t* cef_request_create(void);
-
-///
-/// Structure used to represent post data for a web request. The functions of
-/// this structure may be called on any thread.
-///
-typedef struct _cef_post_data_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if this object is read-only.
-  ///
-  int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_t* self);
-
-  ///
-  /// Returns true (1) if the underlying POST data includes elements that are
-  /// not represented by this cef_post_data_t object (for example, multi-part
-  /// file upload data). Modifying cef_post_data_t objects with excluded
-  /// elements may result in the request failing.
-  ///
-  int(CEF_CALLBACK* has_excluded_elements)(struct _cef_post_data_t* self);
-
-  ///
-  /// Returns the number of existing post data elements.
-  ///
-  size_t(CEF_CALLBACK* get_element_count)(struct _cef_post_data_t* self);
-
-  ///
-  /// Retrieve the post data elements.
-  ///
-  void(CEF_CALLBACK* get_elements)(struct _cef_post_data_t* self,
-                                   size_t* elementsCount,
-                                   struct _cef_post_data_element_t** elements);
-
-  ///
-  /// Remove the specified post data element.  Returns true (1) if the removal
-  /// succeeds.
-  ///
-  int(CEF_CALLBACK* remove_element)(struct _cef_post_data_t* self,
-                                    struct _cef_post_data_element_t* element);
-
-  ///
-  /// Add the specified post data element.  Returns true (1) if the add
-  /// succeeds.
-  ///
-  int(CEF_CALLBACK* add_element)(struct _cef_post_data_t* self,
-                                 struct _cef_post_data_element_t* element);
-
-  ///
-  /// Remove all existing post data elements.
-  ///
-  void(CEF_CALLBACK* remove_elements)(struct _cef_post_data_t* self);
-} cef_post_data_t;
-
-///
-/// Create a new cef_post_data_t object.
-///
-CEF_EXPORT cef_post_data_t* cef_post_data_create(void);
-
-///
-/// Structure used to represent a single element in the request post data. The
-/// functions of this structure may be called on any thread.
-///
-typedef struct _cef_post_data_element_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns true (1) if this object is read-only.
-  ///
-  int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_element_t* self);
-
-  ///
-  /// Remove all contents from the post data element.
-  ///
-  void(CEF_CALLBACK* set_to_empty)(struct _cef_post_data_element_t* self);
-
-  ///
-  /// The post data element will represent a file.
-  ///
-  void(CEF_CALLBACK* set_to_file)(struct _cef_post_data_element_t* self,
-                                  const cef_string_t* fileName);
-
-  ///
-  /// The post data element will represent bytes.  The bytes passed in will be
-  /// copied.
-  ///
-  void(CEF_CALLBACK* set_to_bytes)(struct _cef_post_data_element_t* self,
-                                   size_t size,
-                                   const void* bytes);
-
-  ///
-  /// Return the type of this post data element.
-  ///
-  cef_postdataelement_type_t(CEF_CALLBACK* get_type)(
-      struct _cef_post_data_element_t* self);
-
-  ///
-  /// Return the file name.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_file)(
-      struct _cef_post_data_element_t* self);
-
-  ///
-  /// Return the number of bytes.
-  ///
-  size_t(CEF_CALLBACK* get_bytes_count)(struct _cef_post_data_element_t* self);
-
-  ///
-  /// Read up to |size| bytes into |bytes| and return the number of bytes
-  /// actually read.
-  ///
-  size_t(CEF_CALLBACK* get_bytes)(struct _cef_post_data_element_t* self,
-                                  size_t size,
-                                  void* bytes);
-} cef_post_data_element_t;
-
-///
-/// Create a new cef_post_data_element_t object.
-///
-CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_

include/capi/cef_request_context_capi.h

@@ -1,441 +0,0 @@
-// 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=2c496139ca9a59303b1493ee93d2c3ae96a956c0$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_callback_capi.h"
-#include "include/capi/cef_cookie_capi.h"
-#include "include/capi/cef_extension_capi.h"
-#include "include/capi/cef_extension_handler_capi.h"
-#include "include/capi/cef_media_router_capi.h"
-#include "include/capi/cef_preference_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_request_context_handler_t;
-struct _cef_scheme_handler_factory_t;
-
-///
-/// Callback structure for cef_request_context_t::ResolveHost.
-///
-typedef struct _cef_resolve_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called on the UI thread after the ResolveHost request has completed.
-  /// |result| will be the result code. |resolved_ips| will be the list of
-  /// resolved IP addresses or NULL if the resolution failed.
-  ///
-  void(CEF_CALLBACK* on_resolve_completed)(struct _cef_resolve_callback_t* self,
-                                           cef_errorcode_t result,
-                                           cef_string_list_t resolved_ips);
-} cef_resolve_callback_t;
-
-///
-/// A request context provides request handling for a set of related browser or
-/// URL request objects. A request context can be specified when creating a new
-/// browser via the cef_browser_host_t static factory functions or when creating
-/// a new URL request via the cef_urlrequest_t static factory functions. Browser
-/// objects with different request contexts will never be hosted in the same
-/// render process. Browser objects with the same request context may or may not
-/// be hosted in the same render process depending on the process model. Browser
-/// objects created indirectly via the JavaScript window.open function or
-/// targeted links will share the same render process and the same request
-/// context as the source browser. When running in single-process mode there is
-/// only a single render process (the main process) and so all browsers created
-/// in single-process mode will share the same request context. This will be the
-/// first request context passed into a cef_browser_host_t static factory
-/// function and all other request context objects will be ignored.
-///
-typedef struct _cef_request_context_t {
-  ///
-  /// Base structure.
-  ///
-  cef_preference_manager_t base;
-
-  ///
-  /// Returns true (1) if this object is pointing to the same context as |that|
-  /// object.
-  ///
-  int(CEF_CALLBACK* is_same)(struct _cef_request_context_t* self,
-                             struct _cef_request_context_t* other);
-
-  ///
-  /// Returns true (1) if this object is sharing the same storage as |that|
-  /// object.
-  ///
-  int(CEF_CALLBACK* is_sharing_with)(struct _cef_request_context_t* self,
-                                     struct _cef_request_context_t* other);
-
-  ///
-  /// Returns true (1) if this object is the global context. The global context
-  /// is used by default when creating a browser or URL request with a NULL
-  /// context argument.
-  ///
-  int(CEF_CALLBACK* is_global)(struct _cef_request_context_t* self);
-
-  ///
-  /// Returns the handler for this context if any.
-  ///
-  struct _cef_request_context_handler_t*(CEF_CALLBACK* get_handler)(
-      struct _cef_request_context_t* self);
-
-  ///
-  /// Returns the cache path for this object. If NULL an "incognito mode" in-
-  /// memory cache is being used.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_cache_path)(
-      struct _cef_request_context_t* self);
-
-  ///
-  /// Returns the cookie manager for this object. If |callback| is non-NULL it
-  /// will be executed asnychronously on the UI thread after the manager's
-  /// storage has been initialized.
-  ///
-  struct _cef_cookie_manager_t*(CEF_CALLBACK* get_cookie_manager)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
-
-  ///
-  /// Register a scheme handler factory for the specified |scheme_name| and
-  /// optional |domain_name|. An NULL |domain_name| value for a standard scheme
-  /// will cause the factory to match all domain names. The |domain_name| value
-  /// will be ignored for non-standard schemes. If |scheme_name| is a built-in
-  /// scheme and no handler is returned by |factory| then the built-in scheme
-  /// handler factory will be called. If |scheme_name| is a custom scheme then
-  /// you must also implement the cef_app_t::on_register_custom_schemes()
-  /// function in all processes. This function may be called multiple times to
-  /// change or remove the factory that matches the specified |scheme_name| and
-  /// optional |domain_name|. Returns false (0) if an error occurs. This
-  /// function may be called on any thread in the browser process.
-  ///
-  int(CEF_CALLBACK* register_scheme_handler_factory)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* scheme_name,
-      const cef_string_t* domain_name,
-      struct _cef_scheme_handler_factory_t* factory);
-
-  ///
-  /// Clear all registered scheme handler factories. Returns false (0) on error.
-  /// This function may be called on any thread in the browser process.
-  ///
-  int(CEF_CALLBACK* clear_scheme_handler_factories)(
-      struct _cef_request_context_t* self);
-
-  ///
-  /// Clears all certificate exceptions that were added as part of handling
-  /// cef_request_handler_t::on_certificate_error(). If you call this it is
-  /// recommended that you also call close_all_connections() or you risk not
-  /// being prompted again for server certificates if you reconnect quickly. If
-  /// |callback| is non-NULL it will be executed on the UI thread after
-  /// completion.
-  ///
-  void(CEF_CALLBACK* clear_certificate_exceptions)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
-
-  ///
-  /// Clears all HTTP authentication credentials that were added as part of
-  /// handling GetAuthCredentials. If |callback| is non-NULL it will be executed
-  /// on the UI thread after completion.
-  ///
-  void(CEF_CALLBACK* clear_http_auth_credentials)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
-
-  ///
-  /// Clears all active and idle connections that Chromium currently has. This
-  /// is only recommended if you have released all other CEF objects but don't
-  /// yet want to call cef_shutdown(). If |callback| is non-NULL it will be
-  /// executed on the UI thread after completion.
-  ///
-  void(CEF_CALLBACK* close_all_connections)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
-
-  ///
-  /// Attempts to resolve |origin| to a list of associated IP addresses.
-  /// |callback| will be executed on the UI thread after completion.
-  ///
-  void(CEF_CALLBACK* resolve_host)(struct _cef_request_context_t* self,
-                                   const cef_string_t* origin,
-                                   struct _cef_resolve_callback_t* callback);
-
-  ///
-  /// Load an extension.
-  ///
-  /// If extension resources will be read from disk using the default load
-  /// implementation then |root_directory| should be the absolute path to the
-  /// extension resources directory and |manifest| should be NULL. If extension
-  /// resources will be provided by the client (e.g. via cef_request_handler_t
-  /// and/or cef_extension_handler_t) then |root_directory| should be a path
-  /// component unique to the extension (if not absolute this will be internally
-  /// prefixed with the PK_DIR_RESOURCES path) and |manifest| should contain the
-  /// contents that would otherwise be read from the "manifest.json" file on
-  /// disk.
-  ///
-  /// The loaded extension will be accessible in all contexts sharing the same
-  /// storage (HasExtension returns true (1)). However, only the context on
-  /// which this function was called is considered the loader (DidLoadExtension
-  /// returns true (1)) and only the loader will receive
-  /// cef_request_context_handler_t callbacks for the extension.
-  ///
-  /// cef_extension_handler_t::OnExtensionLoaded will be called on load success
-  /// or cef_extension_handler_t::OnExtensionLoadFailed will be called on load
-  /// failure.
-  ///
-  /// If the extension specifies a background script via the "background"
-  /// manifest key then cef_extension_handler_t::OnBeforeBackgroundBrowser will
-  /// be called to create the background browser. See that function for
-  /// additional information about background scripts.
-  ///
-  /// For visible extension views the client application should evaluate the
-  /// manifest to determine the correct extension URL to load and then pass that
-  /// URL to the cef_browser_host_t::CreateBrowser* function after the extension
-  /// has loaded. For example, the client can look for the "browser_action"
-  /// manifest key as documented at
-  /// https://developer.chrome.com/extensions/browserAction. Extension URLs take
-  /// the form "chrome-extension://<extension_id>/<path>".
-  ///
-  /// Browsers that host extensions differ from normal browsers as follows:
-  ///  - Can access chrome.* JavaScript APIs if allowed by the manifest. Visit
-  ///    chrome://extensions-support for the list of extension APIs currently
-  ///    supported by CEF.
-  ///  - Main frame navigation to non-extension content is blocked.
-  ///  - Pinch-zooming is disabled.
-  ///  - CefBrowserHost::GetExtension returns the hosted extension.
-  ///  - CefBrowserHost::IsBackgroundHost returns true for background hosts.
-  ///
-  /// See https://developer.chrome.com/extensions for extension implementation
-  /// and usage documentation.
-  ///
-  /// WARNING: This function is deprecated and will be removed in ~M127.
-  ///
-  void(CEF_CALLBACK* load_extension)(struct _cef_request_context_t* self,
-                                     const cef_string_t* root_directory,
-                                     struct _cef_dictionary_value_t* manifest,
-                                     struct _cef_extension_handler_t* handler);
-
-  ///
-  /// Returns true (1) if this context was used to load the extension identified
-  /// by |extension_id|. Other contexts sharing the same storage will also have
-  /// access to the extension (see HasExtension). This function must be called
-  /// on the browser process UI thread.
-  ///
-  /// WARNING: This function is deprecated and will be removed in ~M127.
-  ///
-  int(CEF_CALLBACK* did_load_extension)(struct _cef_request_context_t* self,
-                                        const cef_string_t* extension_id);
-
-  ///
-  /// Returns true (1) if this context has access to the extension identified by
-  /// |extension_id|. This may not be the context that was used to load the
-  /// extension (see DidLoadExtension). This function must be called on the
-  /// browser process UI thread.
-  ///
-  /// WARNING: This function is deprecated and will be removed in ~M127.
-  ///
-  int(CEF_CALLBACK* has_extension)(struct _cef_request_context_t* self,
-                                   const cef_string_t* extension_id);
-
-  ///
-  /// Retrieve the list of all extensions that this context has access to (see
-  /// HasExtension). |extension_ids| will be populated with the list of
-  /// extension ID values. Returns true (1) on success. This function must be
-  /// called on the browser process UI thread.
-  ///
-  /// WARNING: This function is deprecated and will be removed in ~M127.
-  ///
-  int(CEF_CALLBACK* get_extensions)(struct _cef_request_context_t* self,
-                                    cef_string_list_t extension_ids);
-
-  ///
-  /// Returns the extension matching |extension_id| or NULL if no matching
-  /// extension is accessible in this context (see HasExtension). This function
-  /// must be called on the browser process UI thread.
-  ///
-  /// WARNING: This function is deprecated and will be removed in ~M127.
-  ///
-  struct _cef_extension_t*(CEF_CALLBACK* get_extension)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* extension_id);
-
-  ///
-  /// Returns the MediaRouter object associated with this context.  If
-  /// |callback| is non-NULL it will be executed asnychronously on the UI thread
-  /// after the manager's context has been initialized.
-  ///
-  struct _cef_media_router_t*(CEF_CALLBACK* get_media_router)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
-
-  ///
-  /// Returns the current value for |content_type| that applies for the
-  /// specified URLs. If both URLs are NULL the default value will be returned.
-  /// Returns nullptr if no value is configured. Must be called on the browser
-  /// process UI thread.
-  ///
-  struct _cef_value_t*(CEF_CALLBACK* get_website_setting)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* requesting_url,
-      const cef_string_t* top_level_url,
-      cef_content_setting_types_t content_type);
-
-  ///
-  /// Sets the current value for |content_type| for the specified URLs in the
-  /// default scope. If both URLs are NULL, and the context is not incognito,
-  /// the default value will be set. Pass nullptr for |value| to remove the
-  /// default value for this content type.
-  ///
-  /// WARNING: Incorrect usage of this function may cause instability or
-  /// security issues in Chromium. Make sure that you first understand the
-  /// potential impact of any changes to |content_type| by reviewing the related
-  /// source code in Chromium. For example, if you plan to modify
-  /// CEF_CONTENT_SETTING_TYPE_POPUPS, first review and understand the usage of
-  /// ContentSettingsType::POPUPS in Chromium:
-  /// https://source.chromium.org/search?q=ContentSettingsType::POPUPS
-  ///
-  void(CEF_CALLBACK* set_website_setting)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* requesting_url,
-      const cef_string_t* top_level_url,
-      cef_content_setting_types_t content_type,
-      struct _cef_value_t* value);
-
-  ///
-  /// Returns the current value for |content_type| that applies for the
-  /// specified URLs. If both URLs are NULL the default value will be returned.
-  /// Returns CEF_CONTENT_SETTING_VALUE_DEFAULT if no value is configured. Must
-  /// be called on the browser process UI thread.
-  ///
-  cef_content_setting_values_t(CEF_CALLBACK* get_content_setting)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* requesting_url,
-      const cef_string_t* top_level_url,
-      cef_content_setting_types_t content_type);
-
-  ///
-  /// Sets the current value for |content_type| for the specified URLs in the
-  /// default scope. If both URLs are NULL, and the context is not incognito,
-  /// the default value will be set. Pass CEF_CONTENT_SETTING_VALUE_DEFAULT for
-  /// |value| to use the default value for this content type.
-  ///
-  /// WARNING: Incorrect usage of this function may cause instability or
-  /// security issues in Chromium. Make sure that you first understand the
-  /// potential impact of any changes to |content_type| by reviewing the related
-  /// source code in Chromium. For example, if you plan to modify
-  /// CEF_CONTENT_SETTING_TYPE_POPUPS, first review and understand the usage of
-  /// ContentSettingsType::POPUPS in Chromium:
-  /// https://source.chromium.org/search?q=ContentSettingsType::POPUPS
-  ///
-  void(CEF_CALLBACK* set_content_setting)(
-      struct _cef_request_context_t* self,
-      const cef_string_t* requesting_url,
-      const cef_string_t* top_level_url,
-      cef_content_setting_types_t content_type,
-      cef_content_setting_values_t value);
-
-  ///
-  /// Sets the Chrome color scheme for all browsers that share this request
-  /// context. |variant| values of SYSTEM, LIGHT and DARK change the underlying
-  /// color mode (e.g. light vs dark). Other |variant| values determine how
-  /// |user_color| will be applied in the current color mode. If |user_color| is
-  /// transparent (0) the default color will be used.
-  ///
-  void(CEF_CALLBACK* set_chrome_color_scheme)(
-      struct _cef_request_context_t* self,
-      cef_color_variant_t variant,
-      cef_color_t user_color);
-
-  ///
-  /// Returns the current Chrome color scheme mode (SYSTEM, LIGHT or DARK). Must
-  /// be called on the browser process UI thread.
-  ///
-  cef_color_variant_t(CEF_CALLBACK* get_chrome_color_scheme_mode)(
-      struct _cef_request_context_t* self);
-
-  ///
-  /// Returns the current Chrome color scheme color, or transparent (0) for the
-  /// default color. Must be called on the browser process UI thread.
-  ///
-  cef_color_t(CEF_CALLBACK* get_chrome_color_scheme_color)(
-      struct _cef_request_context_t* self);
-
-  ///
-  /// Returns the current Chrome color scheme variant. Must be called on the
-  /// browser process UI thread.
-  ///
-  cef_color_variant_t(CEF_CALLBACK* get_chrome_color_scheme_variant)(
-      struct _cef_request_context_t* self);
-} cef_request_context_t;
-
-///
-/// Returns the global context object.
-///
-CEF_EXPORT cef_request_context_t* cef_request_context_get_global_context(void);
-
-///
-/// Creates a new context object with the specified |settings| and optional
-/// |handler|.
-///
-CEF_EXPORT cef_request_context_t* cef_request_context_create_context(
-    const struct _cef_request_context_settings_t* settings,
-    struct _cef_request_context_handler_t* handler);
-
-///
-/// Creates a new context object that shares storage with |other| and uses an
-/// optional |handler|.
-///
-CEF_EXPORT cef_request_context_t* cef_create_context_shared(
-    cef_request_context_t* other,
-    struct _cef_request_context_handler_t* handler);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_

include/capi/cef_request_context_handler_capi.h

@@ -1,108 +0,0 @@
-// 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=d90d816565429ad304f43490b0619af5ffa70274$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_frame_capi.h"
-#include "include/capi/cef_preference_capi.h"
-#include "include/capi/cef_request_capi.h"
-#include "include/capi/cef_resource_request_handler_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Implement this structure to provide handler implementations. The handler
-/// instance will not be released until all objects related to the context have
-/// been destroyed.
-///
-typedef struct _cef_request_context_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called on the browser process UI thread immediately after the request
-  /// context has been initialized.
-  ///
-  void(CEF_CALLBACK* on_request_context_initialized)(
-      struct _cef_request_context_handler_t* self,
-      struct _cef_request_context_t* request_context);
-
-  ///
-  /// Called on the browser process IO thread before a resource request is
-  /// initiated. The |browser| and |frame| values represent the source of the
-  /// request, and may be NULL for requests originating from service workers or
-  /// cef_urlrequest_t. |request| represents the request contents and cannot be
-  /// modified in this callback. |is_navigation| will be true (1) if the
-  /// resource request is a navigation. |is_download| will be true (1) if the
-  /// resource request is a download. |request_initiator| is the origin (scheme
-  /// + domain) of the page that initiated the request. Set
-  /// |disable_default_handling| to true (1) to disable default handling of the
-  /// request, in which case it will need to be handled via
-  /// cef_resource_request_handler_t::GetResourceHandler or it will be canceled.
-  /// To allow the resource load to proceed with default handling return NULL.
-  /// To specify a handler for the resource return a
-  /// cef_resource_request_handler_t object. This function will not be called if
-  /// the client associated with |browser| returns a non-NULL value from
-  /// cef_request_handler_t::GetResourceRequestHandler for the same request
-  /// (identified by cef_request_t::GetIdentifier).
-  ///
-  struct _cef_resource_request_handler_t*(
-      CEF_CALLBACK* get_resource_request_handler)(
-      struct _cef_request_context_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      int is_navigation,
-      int is_download,
-      const cef_string_t* request_initiator,
-      int* disable_default_handling);
-} cef_request_context_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_

include/capi/cef_request_handler_capi.h

@@ -1,287 +0,0 @@
-// 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=2e8b5c5107f61e3d4c333dc02c76a9f30cd0cf83$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_auth_callback_capi.h"
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_callback_capi.h"
-#include "include/capi/cef_frame_capi.h"
-#include "include/capi/cef_request_capi.h"
-#include "include/capi/cef_resource_request_handler_capi.h"
-#include "include/capi/cef_ssl_info_capi.h"
-#include "include/capi/cef_unresponsive_process_callback_capi.h"
-#include "include/capi/cef_x509_certificate_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback structure used to select a client certificate for authentication.
-///
-typedef struct _cef_select_client_certificate_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Chooses the specified certificate for client certificate authentication.
-  /// NULL value means that no client certificate should be used.
-  ///
-  void(CEF_CALLBACK* select)(
-      struct _cef_select_client_certificate_callback_t* self,
-      struct _cef_x509certificate_t* cert);
-} cef_select_client_certificate_callback_t;
-
-///
-/// Implement this structure to handle events related to browser requests. The
-/// functions of this structure will be called on the thread indicated.
-///
-typedef struct _cef_request_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called on the UI thread before browser navigation. Return true (1) to
-  /// cancel the navigation or false (0) to allow the navigation to proceed. The
-  /// |request| object cannot be modified in this callback.
-  /// cef_load_handler_t::OnLoadingStateChange will be called twice in all
-  /// cases. If the navigation is allowed cef_load_handler_t::OnLoadStart and
-  /// cef_load_handler_t::OnLoadEnd will be called. If the navigation is
-  /// canceled cef_load_handler_t::OnLoadError will be called with an
-  /// |errorCode| value of ERR_ABORTED. The |user_gesture| value will be true
-  /// (1) if the browser navigated via explicit user gesture (e.g. clicking a
-  /// link) or false (0) if it navigated automatically (e.g. via the
-  /// DomContentLoaded event).
-  ///
-  int(CEF_CALLBACK* on_before_browse)(struct _cef_request_handler_t* self,
-                                      struct _cef_browser_t* browser,
-                                      struct _cef_frame_t* frame,
-                                      struct _cef_request_t* request,
-                                      int user_gesture,
-                                      int is_redirect);
-
-  ///
-  /// Called on the UI thread before OnBeforeBrowse in certain limited cases
-  /// where navigating a new or different browser might be desirable. This
-  /// includes user-initiated navigation that might open in a special way (e.g.
-  /// links clicked via middle-click or ctrl + left-click) and certain types of
-  /// cross-origin navigation initiated from the renderer process (e.g.
-  /// navigating the top-level frame to/from a file URL). The |browser| and
-  /// |frame| values represent the source of the navigation. The
-  /// |target_disposition| value indicates where the user intended to navigate
-  /// the browser based on standard Chromium behaviors (e.g. current tab, new
-  /// tab, etc). The |user_gesture| value will be true (1) if the browser
-  /// navigated via explicit user gesture (e.g. clicking a link) or false (0) if
-  /// it navigated automatically (e.g. via the DomContentLoaded event). Return
-  /// true (1) to cancel the navigation or false (0) to allow the navigation to
-  /// proceed in the source browser's top-level frame.
-  ///
-  int(CEF_CALLBACK* on_open_urlfrom_tab)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      const cef_string_t* target_url,
-      cef_window_open_disposition_t target_disposition,
-      int user_gesture);
-
-  ///
-  /// Called on the browser process IO thread before a resource request is
-  /// initiated. The |browser| and |frame| values represent the source of the
-  /// request. |request| represents the request contents and cannot be modified
-  /// in this callback. |is_navigation| will be true (1) if the resource request
-  /// is a navigation. |is_download| will be true (1) if the resource request is
-  /// a download. |request_initiator| is the origin (scheme + domain) of the
-  /// page that initiated the request. Set |disable_default_handling| to true
-  /// (1) to disable default handling of the request, in which case it will need
-  /// to be handled via cef_resource_request_handler_t::GetResourceHandler or it
-  /// will be canceled. To allow the resource load to proceed with default
-  /// handling return NULL. To specify a handler for the resource return a
-  /// cef_resource_request_handler_t object. If this callback returns NULL the
-  /// same function will be called on the associated
-  /// cef_request_context_handler_t, if any.
-  ///
-  struct _cef_resource_request_handler_t*(
-      CEF_CALLBACK* get_resource_request_handler)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      int is_navigation,
-      int is_download,
-      const cef_string_t* request_initiator,
-      int* disable_default_handling);
-
-  ///
-  /// Called on the IO thread when the browser needs credentials from the user.
-  /// |origin_url| is the origin making this authentication request. |isProxy|
-  /// indicates whether the host is a proxy server. |host| contains the hostname
-  /// and |port| contains the port number. |realm| is the realm of the challenge
-  /// and may be NULL. |scheme| is the authentication scheme used, such as
-  /// "basic" or "digest", and will be NULL if the source of the request is an
-  /// FTP server. Return true (1) to continue the request and call
-  /// cef_auth_callback_t::cont() either in this function or at a later time
-  /// when the authentication information is available. Return false (0) to
-  /// cancel the request immediately.
-  ///
-  int(CEF_CALLBACK* get_auth_credentials)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      const cef_string_t* origin_url,
-      int isProxy,
-      const cef_string_t* host,
-      int port,
-      const cef_string_t* realm,
-      const cef_string_t* scheme,
-      struct _cef_auth_callback_t* callback);
-
-  ///
-  /// Called on the UI thread to handle requests for URLs with an invalid SSL
-  /// certificate. Return true (1) and call cef_callback_t functions either in
-  /// this function or at a later time to continue or cancel the request. Return
-  /// false (0) to cancel the request immediately. If
-  /// cef_settings_t.ignore_certificate_errors is set all invalid certificates
-  /// will be accepted without calling this function.
-  ///
-  int(CEF_CALLBACK* on_certificate_error)(struct _cef_request_handler_t* self,
-                                          struct _cef_browser_t* browser,
-                                          cef_errorcode_t cert_error,
-                                          const cef_string_t* request_url,
-                                          struct _cef_sslinfo_t* ssl_info,
-                                          struct _cef_callback_t* callback);
-
-  ///
-  /// Called on the UI thread when a client certificate is being requested for
-  /// authentication. Return false (0) to use the default behavior and
-  /// automatically select the first certificate available. Return true (1) and
-  /// call cef_select_client_certificate_callback_t::Select either in this
-  /// function or at a later time to select a certificate. Do not call Select or
-  /// call it with NULL to continue without using any certificate. |isProxy|
-  /// indicates whether the host is an HTTPS proxy or the origin server. |host|
-  /// and |port| contains the hostname and port of the SSL server.
-  /// |certificates| is the list of certificates to choose from; this list has
-  /// already been pruned by Chromium so that it only contains certificates from
-  /// issuers that the server trusts.
-  ///
-  int(CEF_CALLBACK* on_select_client_certificate)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      int isProxy,
-      const cef_string_t* host,
-      int port,
-      size_t certificatesCount,
-      struct _cef_x509certificate_t* const* certificates,
-      struct _cef_select_client_certificate_callback_t* callback);
-
-  ///
-  /// Called on the browser process UI thread when the render view associated
-  /// with |browser| is ready to receive/handle IPC messages in the render
-  /// process.
-  ///
-  void(CEF_CALLBACK* on_render_view_ready)(struct _cef_request_handler_t* self,
-                                           struct _cef_browser_t* browser);
-
-  ///
-  /// Called on the browser process UI thread when the render process is
-  /// unresponsive as indicated by a lack of input event processing for at least
-  /// 15 seconds. Return false (0) for the default behavior which is an
-  /// indefinite wait with the Alloy runtime or display of the "Page
-  /// unresponsive" dialog with the Chrome runtime. Return true (1) and don't
-  /// execute the callback for an indefinite wait without display of the Chrome
-  /// runtime dialog. Return true (1) and call
-  /// cef_unresponsive_process_callback_t::Wait either in this function or at a
-  /// later time to reset the wait timer, potentially triggering another call to
-  /// this function if the process remains unresponsive. Return true (1) and
-  /// call cef_unresponsive_process_callback_t:: Terminate either in this
-  /// function or at a later time to terminate the unresponsive process,
-  /// resulting in a call to OnRenderProcessTerminated.
-  /// OnRenderProcessResponsive will be called if the process becomes responsive
-  /// after this function is called. This functionality depends on the hang
-  /// monitor which can be disabled by passing the `--disable-hang-monitor`
-  /// command-line flag.
-  ///
-  int(CEF_CALLBACK* on_render_process_unresponsive)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_unresponsive_process_callback_t* callback);
-
-  ///
-  /// Called on the browser process UI thread when the render process becomes
-  /// responsive after previously being unresponsive. See documentation on
-  /// OnRenderProcessUnresponsive.
-  ///
-  void(CEF_CALLBACK* on_render_process_responsive)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser);
-
-  ///
-  /// Called on the browser process UI thread when the render process terminates
-  /// unexpectedly. |status| indicates how the process terminated. |error_code|
-  /// and |error_string| represent the error that would be displayed in Chrome's
-  /// "Aw, Snap!" view. Possible |error_code| values include cef_resultcode_t
-  /// non-normal exit values and platform-specific crash values (for example, a
-  /// Posix signal or Windows hardware exception).
-  ///
-  void(CEF_CALLBACK* on_render_process_terminated)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      cef_termination_status_t status,
-      int error_code,
-      const cef_string_t* error_string);
-
-  ///
-  /// Called on the browser process UI thread when the window.document object of
-  /// the main frame has been created.
-  ///
-  void(CEF_CALLBACK* on_document_available_in_main_frame)(
-      struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser);
-} cef_request_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_

include/capi/cef_resource_bundle_capi.h

@@ -1,104 +0,0 @@
-// 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=d97d3ca6c8d610627538c58f3b4ba3869f3d9ac7$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_values_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure used for retrieving resources from the resource bundle (*.pak)
-/// files loaded by CEF during startup or via the cef_resource_bundle_handler_t
-/// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for
-/// additional options related to resource bundle loading. The functions of this
-/// structure may be called on any thread unless otherwise indicated.
-///
-typedef struct _cef_resource_bundle_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Returns the localized string for the specified |string_id| or an NULL
-  /// string if the value is not found. Include cef_pack_strings.h for a listing
-  /// of valid string ID values.
-  ///
-  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t(CEF_CALLBACK* get_localized_string)(
-      struct _cef_resource_bundle_t* self,
-      int string_id);
-
-  ///
-  /// Returns a cef_binary_value_t containing the decompressed contents of the
-  /// specified scale independent |resource_id| or NULL if not found. Include
-  /// cef_pack_resources.h for a listing of valid resource ID values.
-  ///
-  struct _cef_binary_value_t*(CEF_CALLBACK* get_data_resource)(
-      struct _cef_resource_bundle_t* self,
-      int resource_id);
-
-  ///
-  /// Returns a cef_binary_value_t containing the decompressed contents of the
-  /// specified |resource_id| nearest the scale factor |scale_factor| or NULL if
-  /// not found. Use a |scale_factor| value of SCALE_FACTOR_NONE for scale
-  /// independent resources or call GetDataResource instead.Include
-  /// cef_pack_resources.h for a listing of valid resource ID values.
-  ///
-  struct _cef_binary_value_t*(CEF_CALLBACK* get_data_resource_for_scale)(
-      struct _cef_resource_bundle_t* self,
-      int resource_id,
-      cef_scale_factor_t scale_factor);
-} cef_resource_bundle_t;
-
-///
-/// Returns the global resource bundle instance.
-///
-CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_

include/capi/cef_resource_bundle_handler_capi.h

@@ -1,105 +0,0 @@
-// 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=b25f3131d67980e493da4d7e484676d000334995$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Structure used to implement a custom resource bundle structure. See
-/// CefSettings for additional options related to resource bundle loading. The
-/// functions of this structure may be called on multiple threads.
-///
-typedef struct _cef_resource_bundle_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called to retrieve a localized translation for the specified |string_id|.
-  /// To provide the translation set |string| to the translation string and
-  /// return true (1). To use the default translation return false (0). Include
-  /// cef_pack_strings.h for a listing of valid string ID values.
-  ///
-  int(CEF_CALLBACK* get_localized_string)(
-      struct _cef_resource_bundle_handler_t* self,
-      int string_id,
-      cef_string_t* string);
-
-  ///
-  /// Called to retrieve data for the specified scale independent |resource_id|.
-  /// To provide the resource data set |data| and |data_size| to the data
-  /// pointer and size respectively and return true (1). To use the default
-  /// resource data return false (0). The resource data will not be copied and
-  /// must remain resident in memory. Include cef_pack_resources.h for a listing
-  /// of valid resource ID values.
-  ///
-  int(CEF_CALLBACK* get_data_resource)(
-      struct _cef_resource_bundle_handler_t* self,
-      int resource_id,
-      void** data,
-      size_t* data_size);
-
-  ///
-  /// Called to retrieve data for the specified |resource_id| nearest the scale
-  /// factor |scale_factor|. To provide the resource data set |data| and
-  /// |data_size| to the data pointer and size respectively and return true (1).
-  /// To use the default resource data return false (0). The resource data will
-  /// not be copied and must remain resident in memory. Include
-  /// cef_pack_resources.h for a listing of valid resource ID values.
-  ///
-  int(CEF_CALLBACK* get_data_resource_for_scale)(
-      struct _cef_resource_bundle_handler_t* self,
-      int resource_id,
-      cef_scale_factor_t scale_factor,
-      void** data,
-      size_t* data_size);
-} cef_resource_bundle_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_

include/capi/cef_resource_handler_capi.h

@@ -1,210 +0,0 @@
-// 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=ad8218a8ac9e313884110e72bb2af32ec916907f$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_callback_capi.h"
-#include "include/capi/cef_cookie_capi.h"
-#include "include/capi/cef_request_capi.h"
-#include "include/capi/cef_response_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-///
-/// Callback for asynchronous continuation of cef_resource_handler_t::skip().
-///
-typedef struct _cef_resource_skip_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Callback for asynchronous continuation of skip(). If |bytes_skipped| > 0
-  /// then either skip() will be called again until the requested number of
-  /// bytes have been skipped or the request will proceed. If |bytes_skipped| <=
-  /// 0 the request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_resource_skip_callback_t* self,
-                           int64_t bytes_skipped);
-} cef_resource_skip_callback_t;
-
-///
-/// Callback for asynchronous continuation of cef_resource_handler_t::read().
-///
-typedef struct _cef_resource_read_callback_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Callback for asynchronous continuation of read(). If |bytes_read| == 0 the
-  /// response will be considered complete. If |bytes_read| > 0 then read() will
-  /// be called again until the request is complete (based on either the result
-  /// or the expected content length). If |bytes_read| < 0 then the request will
-  /// fail and the |bytes_read| value will be treated as the error code.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_resource_read_callback_t* self,
-                           int bytes_read);
-} cef_resource_read_callback_t;
-
-///
-/// Structure used to implement a custom request handler structure. The
-/// functions of this structure will be called on the IO thread unless otherwise
-/// indicated.
-///
-typedef struct _cef_resource_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Open the response stream. To handle the request immediately set
-  /// |handle_request| to true (1) and return true (1). To decide at a later
-  /// time set |handle_request| to false (0), return true (1), and execute
-  /// |callback| to continue or cancel the request. To cancel the request
-  /// immediately set |handle_request| to true (1) and return false (0). This
-  /// function will be called in sequence but not from a dedicated thread. For
-  /// backwards compatibility set |handle_request| to false (0) and return false
-  /// (0) and the ProcessRequest function will be called.
-  ///
-  int(CEF_CALLBACK* open)(struct _cef_resource_handler_t* self,
-                          struct _cef_request_t* request,
-                          int* handle_request,
-                          struct _cef_callback_t* callback);
-
-  ///
-  /// Begin processing the request. To handle the request return true (1) and
-  /// call cef_callback_t::cont() once the response header information is
-  /// available (cef_callback_t::cont() can also be called from inside this
-  /// function if header information is available immediately). To cancel the
-  /// request return false (0).
-  ///
-  /// WARNING: This function is deprecated. Use Open instead.
-  ///
-  int(CEF_CALLBACK* process_request)(struct _cef_resource_handler_t* self,
-                                     struct _cef_request_t* request,
-                                     struct _cef_callback_t* callback);
-
-  ///
-  /// Retrieve response header information. If the response length is not known
-  /// set |response_length| to -1 and read_response() will be called until it
-  /// returns false (0). If the response length is known set |response_length|
-  /// to a positive value and read_response() will be called until it returns
-  /// false (0) or the specified number of bytes have been read. Use the
-  /// |response| object to set the mime type, http status code and other
-  /// optional header values. To redirect the request to a new URL set
-  /// |redirectUrl| to the new URL. |redirectUrl| can be either a relative or
-  /// fully qualified URL. It is also possible to set |response| to a redirect
-  /// http status code and pass the new URL via a Location header. Likewise with
-  /// |redirectUrl| it is valid to set a relative or fully qualified URL as the
-  /// Location header value. If an error occured while setting up the request
-  /// you can call set_error() on |response| to indicate the error condition.
-  ///
-  void(CEF_CALLBACK* get_response_headers)(struct _cef_resource_handler_t* self,
-                                           struct _cef_response_t* response,
-                                           int64_t* response_length,
-                                           cef_string_t* redirectUrl);
-
-  ///
-  /// Skip response data when requested by a Range header. Skip over and discard
-  /// |bytes_to_skip| bytes of response data. If data is available immediately
-  /// set |bytes_skipped| to the number of bytes skipped and return true (1). To
-  /// read the data at a later time set |bytes_skipped| to 0, return true (1)
-  /// and execute |callback| when the data is available. To indicate failure set
-  /// |bytes_skipped| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This
-  /// function will be called in sequence but not from a dedicated thread.
-  ///
-  int(CEF_CALLBACK* skip)(struct _cef_resource_handler_t* self,
-                          int64_t bytes_to_skip,
-                          int64_t* bytes_skipped,
-                          struct _cef_resource_skip_callback_t* callback);
-
-  ///
-  /// Read response data. If data is available immediately copy up to
-  /// |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
-  /// bytes copied, and return true (1). To read the data at a later time keep a
-  /// pointer to |data_out|, set |bytes_read| to 0, return true (1) and execute
-  /// |callback| when the data is available (|data_out| will remain valid until
-  /// the callback is executed). To indicate response completion set
-  /// |bytes_read| to 0 and return false (0). To indicate failure set
-  /// |bytes_read| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This
-  /// function will be called in sequence but not from a dedicated thread. For
-  /// backwards compatibility set |bytes_read| to -1 and return false (0) and
-  /// the ReadResponse function will be called.
-  ///
-  int(CEF_CALLBACK* read)(struct _cef_resource_handler_t* self,
-                          void* data_out,
-                          int bytes_to_read,
-                          int* bytes_read,
-                          struct _cef_resource_read_callback_t* callback);
-
-  ///
-  /// Read response data. If data is available immediately copy up to
-  /// |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
-  /// bytes copied, and return true (1). To read the data at a later time set
-  /// |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when
-  /// the data is available. To indicate response completion return false (0).
-  ///
-  /// WARNING: This function is deprecated. Use Skip and Read instead.
-  ///
-  int(CEF_CALLBACK* read_response)(struct _cef_resource_handler_t* self,
-                                   void* data_out,
-                                   int bytes_to_read,
-                                   int* bytes_read,
-                                   struct _cef_callback_t* callback);
-
-  ///
-  /// Request processing has been canceled.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_resource_handler_t* self);
-} cef_resource_handler_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_

include/capi/cef_resource_request_handler_capi.h

@@ -1,255 +0,0 @@
-// 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=c4416644786e3c1999cdcd7e6bf78af94ff7f0da$
-//
-
-#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_
-#pragma once
-
-#include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_browser_capi.h"
-#include "include/capi/cef_callback_capi.h"
-#include "include/capi/cef_frame_capi.h"
-#include "include/capi/cef_request_capi.h"
-#include "include/capi/cef_resource_handler_capi.h"
-#include "include/capi/cef_response_capi.h"
-#include "include/capi/cef_response_filter_capi.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _cef_cookie_access_filter_t;
-
-///
-/// Implement this structure to handle events related to browser requests. The
-/// functions of this structure will be called on the IO thread unless otherwise
-/// indicated.
-///
-typedef struct _cef_resource_request_handler_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called on the IO thread before a resource request is loaded. The |browser|
-  /// and |frame| values represent the source of the request, and may be NULL
-  /// for requests originating from service workers or cef_urlrequest_t. To
-  /// optionally filter cookies for the request return a
-  /// cef_cookie_access_filter_t object. The |request| object cannot not be
-  /// modified in this callback.
-  ///
-  struct _cef_cookie_access_filter_t*(CEF_CALLBACK* get_cookie_access_filter)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request);
-
-  ///
-  /// Called on the IO thread before a resource request is loaded. The |browser|
-  /// and |frame| values represent the source of the request, and may be NULL
-  /// for requests originating from service workers or cef_urlrequest_t. To
-  /// redirect or change the resource load optionally modify |request|.
-  /// Modification of the request URL will be treated as a redirect. Return
-  /// RV_CONTINUE to continue the request immediately. Return RV_CONTINUE_ASYNC
-  /// and call cef_callback_t functions at a later time to continue or cancel
-  /// the request asynchronously. Return RV_CANCEL to cancel the request
-  /// immediately.
-  ///
-  cef_return_value_t(CEF_CALLBACK* on_before_resource_load)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      struct _cef_callback_t* callback);
-
-  ///
-  /// Called on the IO thread before a resource is loaded. The |browser| and
-  /// |frame| values represent the source of the request, and may be NULL for
-  /// requests originating from service workers or cef_urlrequest_t. To allow
-  /// the resource to load using the default network loader return NULL. To
-  /// specify a handler for the resource return a cef_resource_handler_t object.
-  /// The |request| object cannot not be modified in this callback.
-  ///
-  struct _cef_resource_handler_t*(CEF_CALLBACK* get_resource_handler)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request);
-
-  ///
-  /// Called on the IO thread when a resource load is redirected. The |browser|
-  /// and |frame| values represent the source of the request, and may be NULL
-  /// for requests originating from service workers or cef_urlrequest_t. The
-  /// |request| parameter will contain the old URL and other request-related
-  /// information. The |response| parameter will contain the response that
-  /// resulted in the redirect. The |new_url| parameter will contain the new URL
-  /// and can be changed if desired. The |request| and |response| objects cannot
-  /// be modified in this callback.
-  ///
-  void(CEF_CALLBACK* on_resource_redirect)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      struct _cef_response_t* response,
-      cef_string_t* new_url);
-
-  ///
-  /// Called on the IO thread when a resource response is received. The
-  /// |browser| and |frame| values represent the source of the request, and may
-  /// be NULL for requests originating from service workers or cef_urlrequest_t.
-  /// To allow the resource load to proceed without modification return false
-  /// (0). To redirect or retry the resource load optionally modify |request|
-  /// and return true (1). Modification of the request URL will be treated as a
-  /// redirect. Requests handled using the default network loader cannot be
-  /// redirected in this callback. The |response| object cannot be modified in
-  /// this callback.
-  ///
-  /// WARNING: Redirecting using this function is deprecated. Use
-  /// OnBeforeResourceLoad or GetResourceHandler to perform redirects.
-  ///
-  int(CEF_CALLBACK* on_resource_response)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      struct _cef_response_t* response);
-
-  ///
-  /// Called on the IO thread to optionally filter resource response content.
-  /// The |browser| and |frame| values represent the source of the request, and
-  /// may be NULL for requests originating from service workers or
-  /// cef_urlrequest_t. |request| and |response| represent the request and
-  /// response respectively and cannot be modified in this callback.
-  ///
-  struct _cef_response_filter_t*(CEF_CALLBACK* get_resource_response_filter)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      struct _cef_response_t* response);
-
-  ///
-  /// Called on the IO thread when a resource load has completed. The |browser|
-  /// and |frame| values represent the source of the request, and may be NULL
-  /// for requests originating from service workers or cef_urlrequest_t.
-  /// |request| and |response| represent the request and response respectively
-  /// and cannot be modified in this callback. |status| indicates the load
-  /// completion status. |received_content_length| is the number of response
-  /// bytes actually read. This function will be called for all requests,
-  /// including requests that are aborted due to CEF shutdown or destruction of
-  /// the associated browser. In cases where the associated browser is destroyed
-  /// this callback may arrive after the cef_life_span_handler_t::OnBeforeClose
-  /// callback for that browser. The cef_frame_t::IsValid function can be used
-  /// to test for this situation, and care should be taken not to call |browser|
-  /// or |frame| functions that modify state (like LoadURL, SendProcessMessage,
-  /// etc.) if the frame is invalid.
-  ///
-  void(CEF_CALLBACK* on_resource_load_complete)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      struct _cef_response_t* response,
-      cef_urlrequest_status_t status,
-      int64_t received_content_length);
-
-  ///
-  /// Called on the IO thread to handle requests for URLs with an unknown
-  /// protocol component. The |browser| and |frame| values represent the source
-  /// of the request, and may be NULL for requests originating from service
-  /// workers or cef_urlrequest_t. |request| cannot be modified in this
-  /// callback. Set |allow_os_execution| to true (1) to attempt execution via
-  /// the registered OS protocol handler, if any. SECURITY WARNING: YOU SHOULD
-  /// USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR OTHER URL
-  /// ANALYSIS BEFORE ALLOWING OS EXECUTION.
-  ///
-  void(CEF_CALLBACK* on_protocol_execution)(
-      struct _cef_resource_request_handler_t* self,
-      struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame,
-      struct _cef_request_t* request,
-      int* allow_os_execution);
-} cef_resource_request_handler_t;
-
-///
-/// Implement this structure to filter cookies that may be sent or received from
-/// resource requests. The functions of this structure will be called on the IO
-/// thread unless otherwise indicated.
-///
-typedef struct _cef_cookie_access_filter_t {
-  ///
-  /// Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  /// Called on the IO thread before a resource request is sent. The |browser|
-  /// and |frame| values represent the source of the request, and may be NULL
-  /// for requests originating from service workers or cef_urlrequest_t.
-  /// |request| cannot be modified in this callback. Return true (1) if the
-  /// specified cookie can be sent with the request or false (0) otherwise.
-  ///
-  int(CEF_CALLBACK* can_send_cookie)(struct _cef_cookie_access_filter_t* self,
-                                     struct _cef_browser_t* browser,
-                                     struct _cef_frame_t* frame,
-                                     struct _cef_request_t* request,
-                                     const struct _cef_cookie_t* cookie);
-
-  ///
-  /// Called on the IO thread after a resource response is received. The
-  /// |browser| and |frame| values represent the source of the request, and may
-  /// be NULL for requests originating from service workers or cef_urlrequest_t.
-  /// |request| cannot be modified in this callback. Return true (1) if the
-  /// specified cookie returned with the response can be saved or false (0)
-  /// otherwise.
-  ///
-  int(CEF_CALLBACK* can_save_cookie)(struct _cef_cookie_access_filter_t* self,
-                                     struct _cef_browser_t* browser,
-                                     struct _cef_frame_t* frame,
-                                     struct _cef_request_t* request,
-                                     struct _cef_response_t* response,
-                                     const struct _cef_cookie_t* cookie);
-} cef_cookie_access_filter_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_