alloy: Fix crashes related to permissions checks (fixes issue #3379, fixes issue #3381)

This fixes an issue where authentication cookies from SAML responses were not
being saved.

CHROMIUM_BUILD_COMPATIBILITY.txt

@@ -7,6 +7,6 @@
 # https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
 
 {
-  'chromium_checkout': 'refs/tags/91.0.4472.164',
+  'chromium_checkout': 'refs/tags/104.0.5112.102',
-  'depot_tools_checkout': '61bf6e8d69'
+  'depot_tools_checkout': '350d210871'
 }

CMakeLists.txt.in

@@ -11,9 +11,9 @@
 # CMake-generated project formats that have been tested with this CEF binary
 # distribution include:
 #
-# Linux:      Ninja, Unix Makefiles
+# Linux:      Ninja, GCC 7.5.0+, Unix Makefiles
-# MacOS:      Ninja, Xcode 8+ (x86_64) or Xcode 12.2+ (ARM64)
+# MacOS:      Ninja, Xcode 12.2 to 13.0
-# Windows:    Ninja, Visual Studio 2015+
+# Windows:    Ninja, Visual Studio 2019+
 #
 # Ninja is a cross-platform open-source tool for running fast builds using
 # pre-installed platform toolchains (GNU, clang, Xcode or MSVC). It can be
@@ -36,25 +36,27 @@
 #
 # The below requirements must be met to build this CEF binary distribution.
 #
-# - CMake version 2.8.12.1 or newer.
+# - CMake version 3.19 or newer.
 #
 # - Linux requirements:
-#   Currently supported distributions include Debian Wheezy, Ubuntu Precise, and
+#   Currently supported distributions include Debian 10 (Buster), Ubuntu 18
-#   related. Ubuntu 18.04 64-bit is recommended. Newer versions will likely also
+#   (Bionic Beaver), and related. Ubuntu 18.04 64-bit with GCC 7.5.0+ is
-#   work but may not have been tested.
+#   recommended. Newer versions will likely also work but may not have been
+#   tested.
 #   Required packages include:
 #     build-essential
 #     libgtk3.0-dev     (required by the cefclient target only)
 #
 # - MacOS requirements:
-#   Xcode 8 or newer building on MacOS 10.11 (El Capitan) or newer for x86_64.
+#   Xcode 12.2 to 13.0 building on MacOS 10.15.4 (Catalina) or newer. Only
-#   Xcode 12.2 or newer building on MacOS 10.15.4 (Catalina) or newer for ARM64.
+#   64-bit builds are supported. The Xcode command-line tools must also be
-#   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
-#   installed.
+#   recommended.
 #
 # - Windows requirements:
-#   Visual Studio 2015 Update 2 or newer building on Windows 7 or newer. Visual
+#   Visual Studio 2019 or newer building on Windows 7 or newer. Windows 10
-#   Studio 2019 and Windows 10 64-bit are recommended.
+#   64-bit is recommended. Newer versions will likely also work but may not have
+#   been tested.
 #
 # BUILD EXAMPLES
 #
@@ -130,7 +132,8 @@
 # Global setup.
 #
 
-cmake_minimum_required(VERSION 2.8.12.1)
+# For VS2019 and Xcode 12+ support.
+cmake_minimum_required(VERSION 3.19)
 
 # Only generate Debug and Release configuration types.
 set(CMAKE_CONFIGURATION_TYPES Debug Release)

README.md

@@ -45,15 +45,11 @@ The base CEF framework includes support for the C and C++ programming languages.
 
 * .Net (CEF3) - https://github.com/cefsharp/CefSharp
 * .Net (CEF1) - https://bitbucket.org/fddima/cefglue
-* .Net/Mono (CEF3) - https://bitbucket.org/xilium/xilium.cefglue
+* .Net/Mono (CEF3) - https://gitlab.com/xiliumhq/chromiumembedded/cefglue
-* .Net (CEF3) - https://bitbucket.org/chromiumfx/chromiumfx
+* Delphi - https://github.com/hgourvest/dcef3
-* Delphi (CEF1) - http://code.google.com/p/delphichromiumembedded/
+* Delphi - https://github.com/salvadordf/CEF4Delphi
-* Delphi (CEF3) - https://github.com/hgourvest/dcef3
-* Delphi (CEF3) - https://github.com/salvadordf/CEF4Delphi
-* Go - https://github.com/richardwilkes/cef
 * Go - https://github.com/CzarekTomczak/cef2go
 * Java - https://bitbucket.org/chromiumembedded/java-cef
-* Java - http://code.google.com/p/javacef/
 * Python - http://code.google.com/p/cefpython/
 
 If you're the maintainer of a project not listed above and would like your project listed here please either post to the [CEF Forum](http://www.magpcss.org/ceforum/) or contact Marshall directly.
@@ -82,6 +78,6 @@ If you would like to contribute source code changes to CEF please follow the bel
 \- Submit a [pull request](https://bitbucket.org/chromiumembedded/cef/wiki/ContributingWithGit) or create a patch with your changes and attach it to the CEF issue. Changes should:
 
 * Be submitted against the current [CEF master branch](https://bitbucket.org/chromiumembedded/cef/src/?at=master) unless explicitly fixing a bug in a CEF release branch.
-* Follow the style of existing CEF source files. In general CEF uses the [Chromium coding style](http://www.chromium.org/developers/coding-style).
+* Follow the style of existing CEF source files. In general CEF uses the [Chromium C++ style guide](https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md).
 * Include new or modified unit tests as appropriate to the functionality.
 * Not include unnecessary or unrelated changes.

cef_create_projects.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-python tools/gclient_hook.py
+python3 tools/gclient_hook.py

cef_paths.gypi

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 The Chromium Embedded Framework Authors. All rights
+# Copyright (c) 2022 The Chromium Embedded Framework Authors. All rights
 # reserved. Use of this source code is governed by a BSD-style license that
 # can be found in the LICENSE file.
 #
@@ -8,7 +8,7 @@
 # by hand. See the translator.README.txt file in the tools directory for
 # more information.
 #
-# $hash=f1877c7a493342351e284cb6c14e6f223461facb$
+# $hash=3ed1afd1b5f881884e6cfd0186fe41bb7b19fd38$
 #
 
 {
@@ -22,6 +22,7 @@
       'include/cef_browser_process_handler.h',
       'include/cef_callback.h',
       'include/cef_client.h',
+      'include/cef_command_handler.h',
       'include/cef_command_line.h',
       'include/cef_context_menu_handler.h',
       'include/cef_cookie.h',
@@ -40,6 +41,8 @@
       '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',
@@ -52,6 +55,7 @@
       'include/cef_origin_whitelist.h',
       'include/cef_parser.h',
       'include/cef_path_util.h',
+      'include/cef_permission_handler.h',
       'include/cef_print_handler.h',
       'include/cef_print_settings.h',
       'include/cef_process_message.h',
@@ -60,7 +64,6 @@
       'include/cef_render_handler.h',
       'include/cef_render_process_handler.h',
       'include/cef_request.h',
-      'include/cef_request_callback.h',
       'include/cef_request_context.h',
       'include/cef_request_context_handler.h',
       'include/cef_request_handler.h',
@@ -72,6 +75,8 @@
       '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',
@@ -83,7 +88,6 @@
       'include/cef_v8.h',
       'include/cef_values.h',
       'include/cef_waitable_event.h',
-      'include/cef_web_plugin.h',
       'include/cef_x509_certificate.h',
       'include/cef_xml_reader.h',
       'include/cef_zip_reader.h',
@@ -100,6 +104,7 @@
       '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',
@@ -119,6 +124,7 @@
       'include/capi/cef_browser_process_handler_capi.h',
       'include/capi/cef_callback_capi.h',
       'include/capi/cef_client_capi.h',
+      'include/capi/cef_command_handler_capi.h',
       'include/capi/cef_command_line_capi.h',
       'include/capi/cef_context_menu_handler_capi.h',
       'include/capi/cef_cookie_capi.h',
@@ -137,6 +143,8 @@
       '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',
@@ -149,6 +157,7 @@
       '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_print_handler_capi.h',
       'include/capi/cef_print_settings_capi.h',
       'include/capi/cef_process_message_capi.h',
@@ -157,7 +166,6 @@
       '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_callback_capi.h',
       'include/capi/cef_request_context_capi.h',
       'include/capi/cef_request_context_handler_capi.h',
       'include/capi/cef_request_handler_capi.h',
@@ -169,6 +177,8 @@
       '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',
@@ -180,7 +190,6 @@
       'include/capi/cef_v8_capi.h',
       'include/capi/cef_values_capi.h',
       'include/capi/cef_waitable_event_capi.h',
-      'include/capi/cef_web_plugin_capi.h',
       'include/capi/cef_x509_certificate_capi.h',
       'include/capi/cef_xml_reader_capi.h',
       'include/capi/cef_zip_reader_capi.h',
@@ -197,6 +206,7 @@
       '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',
@@ -240,6 +250,8 @@
       'libcef_dll/cpptoc/callback_cpptoc.h',
       'libcef_dll/ctocpp/client_ctocpp.cc',
       'libcef_dll/ctocpp/client_ctocpp.h',
+      'libcef_dll/ctocpp/command_handler_ctocpp.cc',
+      'libcef_dll/ctocpp/command_handler_ctocpp.h',
       'libcef_dll/cpptoc/command_line_cpptoc.cc',
       'libcef_dll/cpptoc/command_line_cpptoc.h',
       'libcef_dll/ctocpp/completion_callback_ctocpp.cc',
@@ -300,6 +312,8 @@
       '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',
@@ -320,6 +334,8 @@
       'libcef_dll/cpptoc/list_value_cpptoc.h',
       'libcef_dll/ctocpp/load_handler_ctocpp.cc',
       'libcef_dll/ctocpp/load_handler_ctocpp.h',
+      'libcef_dll/cpptoc/media_access_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/media_access_callback_cpptoc.h',
       'libcef_dll/ctocpp/media_observer_ctocpp.cc',
       'libcef_dll/ctocpp/media_observer_ctocpp.h',
       'libcef_dll/cpptoc/media_route_cpptoc.cc',
@@ -348,12 +364,18 @@
       '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',
@@ -370,8 +392,6 @@
       'libcef_dll/cpptoc/process_message_cpptoc.h',
       'libcef_dll/ctocpp/read_handler_ctocpp.cc',
       'libcef_dll/ctocpp/read_handler_ctocpp.h',
-      'libcef_dll/ctocpp/register_cdm_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/register_cdm_callback_ctocpp.h',
       'libcef_dll/cpptoc/registration_cpptoc.cc',
       'libcef_dll/cpptoc/registration_cpptoc.h',
       'libcef_dll/ctocpp/render_handler_ctocpp.cc',
@@ -380,8 +400,6 @@
       'libcef_dll/ctocpp/render_process_handler_ctocpp.h',
       'libcef_dll/cpptoc/request_cpptoc.cc',
       'libcef_dll/cpptoc/request_cpptoc.h',
-      'libcef_dll/cpptoc/request_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/request_callback_cpptoc.h',
       'libcef_dll/cpptoc/request_context_cpptoc.cc',
       'libcef_dll/cpptoc/request_context_cpptoc.h',
       'libcef_dll/ctocpp/request_context_handler_ctocpp.cc',
@@ -410,6 +428,8 @@
       'libcef_dll/cpptoc/run_context_menu_callback_cpptoc.h',
       'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.cc',
       'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.h',
+      'libcef_dll/cpptoc/run_quick_menu_callback_cpptoc.cc',
+      'libcef_dll/cpptoc/run_quick_menu_callback_cpptoc.h',
       'libcef_dll/cpptoc/sslinfo_cpptoc.cc',
       'libcef_dll/cpptoc/sslinfo_cpptoc.h',
       'libcef_dll/cpptoc/sslstatus_cpptoc.cc',
@@ -428,6 +448,10 @@
       'libcef_dll/ctocpp/server_handler_ctocpp.h',
       'libcef_dll/ctocpp/set_cookie_callback_ctocpp.cc',
       'libcef_dll/ctocpp/set_cookie_callback_ctocpp.h',
+      'libcef_dll/cpptoc/shared_memory_region_cpptoc.cc',
+      'libcef_dll/cpptoc/shared_memory_region_cpptoc.h',
+      'libcef_dll/cpptoc/shared_process_message_builder_cpptoc.cc',
+      'libcef_dll/cpptoc/shared_process_message_builder_cpptoc.h',
       'libcef_dll/cpptoc/stream_reader_cpptoc.cc',
       'libcef_dll/cpptoc/stream_reader_cpptoc.h',
       'libcef_dll/cpptoc/stream_writer_cpptoc.cc',
@@ -496,12 +520,6 @@
       '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/web_plugin_info_cpptoc.cc',
-      'libcef_dll/cpptoc/web_plugin_info_cpptoc.h',
-      'libcef_dll/ctocpp/web_plugin_info_visitor_ctocpp.cc',
-      'libcef_dll/ctocpp/web_plugin_info_visitor_ctocpp.h',
-      'libcef_dll/ctocpp/web_plugin_unstable_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/web_plugin_unstable_callback_ctocpp.h',
       'libcef_dll/cpptoc/views/window_cpptoc.cc',
       'libcef_dll/cpptoc/views/window_cpptoc.h',
       'libcef_dll/ctocpp/views/window_delegate_ctocpp.cc',
@@ -550,6 +568,8 @@
       'libcef_dll/ctocpp/callback_ctocpp.h',
       'libcef_dll/cpptoc/client_cpptoc.cc',
       'libcef_dll/cpptoc/client_cpptoc.h',
+      'libcef_dll/cpptoc/command_handler_cpptoc.cc',
+      'libcef_dll/cpptoc/command_handler_cpptoc.h',
       'libcef_dll/ctocpp/command_line_ctocpp.cc',
       'libcef_dll/ctocpp/command_line_ctocpp.h',
       'libcef_dll/cpptoc/completion_callback_cpptoc.cc',
@@ -610,6 +630,8 @@
       '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',
@@ -630,6 +652,8 @@
       'libcef_dll/ctocpp/list_value_ctocpp.h',
       'libcef_dll/cpptoc/load_handler_cpptoc.cc',
       'libcef_dll/cpptoc/load_handler_cpptoc.h',
+      'libcef_dll/ctocpp/media_access_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/media_access_callback_ctocpp.h',
       'libcef_dll/cpptoc/media_observer_cpptoc.cc',
       'libcef_dll/cpptoc/media_observer_cpptoc.h',
       'libcef_dll/ctocpp/media_route_ctocpp.cc',
@@ -658,12 +682,18 @@
       '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',
@@ -680,8 +710,6 @@
       'libcef_dll/ctocpp/process_message_ctocpp.h',
       'libcef_dll/cpptoc/read_handler_cpptoc.cc',
       'libcef_dll/cpptoc/read_handler_cpptoc.h',
-      'libcef_dll/cpptoc/register_cdm_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/register_cdm_callback_cpptoc.h',
       'libcef_dll/ctocpp/registration_ctocpp.cc',
       'libcef_dll/ctocpp/registration_ctocpp.h',
       'libcef_dll/cpptoc/render_handler_cpptoc.cc',
@@ -690,8 +718,6 @@
       'libcef_dll/cpptoc/render_process_handler_cpptoc.h',
       'libcef_dll/ctocpp/request_ctocpp.cc',
       'libcef_dll/ctocpp/request_ctocpp.h',
-      'libcef_dll/ctocpp/request_callback_ctocpp.cc',
-      'libcef_dll/ctocpp/request_callback_ctocpp.h',
       'libcef_dll/ctocpp/request_context_ctocpp.cc',
       'libcef_dll/ctocpp/request_context_ctocpp.h',
       'libcef_dll/cpptoc/request_context_handler_cpptoc.cc',
@@ -720,6 +746,8 @@
       'libcef_dll/ctocpp/run_context_menu_callback_ctocpp.h',
       'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.cc',
       'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.h',
+      'libcef_dll/ctocpp/run_quick_menu_callback_ctocpp.cc',
+      'libcef_dll/ctocpp/run_quick_menu_callback_ctocpp.h',
       'libcef_dll/ctocpp/sslinfo_ctocpp.cc',
       'libcef_dll/ctocpp/sslinfo_ctocpp.h',
       'libcef_dll/ctocpp/sslstatus_ctocpp.cc',
@@ -738,6 +766,10 @@
       'libcef_dll/cpptoc/server_handler_cpptoc.h',
       'libcef_dll/cpptoc/set_cookie_callback_cpptoc.cc',
       'libcef_dll/cpptoc/set_cookie_callback_cpptoc.h',
+      'libcef_dll/ctocpp/shared_memory_region_ctocpp.cc',
+      'libcef_dll/ctocpp/shared_memory_region_ctocpp.h',
+      'libcef_dll/ctocpp/shared_process_message_builder_ctocpp.cc',
+      'libcef_dll/ctocpp/shared_process_message_builder_ctocpp.h',
       'libcef_dll/ctocpp/stream_reader_ctocpp.cc',
       'libcef_dll/ctocpp/stream_reader_ctocpp.h',
       'libcef_dll/ctocpp/stream_writer_ctocpp.cc',
@@ -806,12 +838,6 @@
       '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/web_plugin_info_ctocpp.cc',
-      'libcef_dll/ctocpp/web_plugin_info_ctocpp.h',
-      'libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.cc',
-      'libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.h',
-      'libcef_dll/cpptoc/web_plugin_unstable_callback_cpptoc.cc',
-      'libcef_dll/cpptoc/web_plugin_unstable_callback_cpptoc.h',
       'libcef_dll/ctocpp/views/window_ctocpp.cc',
       'libcef_dll/ctocpp/views/window_ctocpp.h',
       'libcef_dll/cpptoc/views/window_delegate_cpptoc.cc',

cef_paths2.gypi

@@ -5,23 +5,26 @@
 {
   'variables': {
     'includes_common': [
+      'include/base/cef_atomic_flag.h',
       'include/base/cef_atomic_ref_count.h',
-      'include/base/cef_atomicops.h',
+      'include/base/cef_auto_reset.h',
       'include/base/cef_basictypes.h',
       'include/base/cef_bind.h',
-      'include/base/cef_bind_helpers.h',
       'include/base/cef_build.h',
       'include/base/cef_callback.h',
       'include/base/cef_callback_forward.h',
+      'include/base/cef_callback_helpers.h',
       'include/base/cef_callback_list.h',
       'include/base/cef_cancelable_callback.h',
+      'include/base/cef_compiler_specific.h',
+      'include/base/cef_cxx17_backports.h',
       'include/base/cef_lock.h',
       'include/base/cef_logging.h',
       'include/base/cef_macros.h',
-      'include/base/cef_move.h',
       'include/base/cef_platform_thread.h',
+      'include/base/cef_ptr_util.h',
       'include/base/cef_ref_counted.h',
-      'include/base/cef_scoped_ptr.h',
+      'include/base/cef_scoped_refptr.h',
       'include/base/cef_template_util.h',
       'include/base/cef_thread_checker.h',
       'include/base/cef_trace_event.h',
@@ -31,10 +34,10 @@
       'include/base/internal/cef_callback_internal.h',
       'include/base/internal/cef_lock_impl.h',
       'include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h',
+      'include/base/internal/cef_scoped_policy.h',
       'include/base/internal/cef_thread_checker_impl.h',
       'include/cef_api_hash.h',
       'include/cef_base.h',
-      'include/cef_config.h',
       'include/cef_version.h',
       'include/internal/cef_export.h',
       'include/internal/cef_ptr.h',
@@ -52,6 +55,7 @@
       'include/internal/cef_time.h',
       'include/internal/cef_trace_event_internal.h',
       'include/internal/cef_types.h',
+      'include/internal/cef_types_geometry.h',
     ],
     'includes_capi': [
       'include/capi/cef_base_capi.h',
@@ -71,9 +75,6 @@
       'include/wrapper/cef_library_loader.h',
     ],
     'includes_win': [
-      'include/base/internal/cef_atomicops_arm64_msvc.h',
-      'include/base/internal/cef_atomicops_x86_msvc.h',
-      'include/base/internal/cef_bind_internal_win.h',
       'include/cef_sandbox_win.h',
       'include/internal/cef_win.h',
     ],
@@ -81,8 +82,8 @@
       'include/internal/cef_types_win.h',
     ],
     'includes_mac': [
-      'include/base/internal/cef_atomicops_atomicword_compat.h',
+      'include/base/cef_scoped_typeref_mac.h',
-      'include/base/internal/cef_atomicops_mac.h',
+      'include/base/internal/cef_scoped_block_mac.h',
       'include/cef_application_mac.h',
       'include/cef_sandbox_mac.h',
       'include/internal/cef_mac.h',
@@ -91,10 +92,6 @@
       'include/internal/cef_types_mac.h',
     ],
     'includes_linux': [
-      'include/base/internal/cef_atomicops_atomicword_compat.h',
-      'include/base/internal/cef_atomicops_arm_gcc.h',
-      'include/base/internal/cef_atomicops_arm64_gcc.h',
-      'include/base/internal/cef_atomicops_x86_gcc.h',
       'include/internal/cef_linux.h',
     ],
     'includes_linux_capi': [
@@ -115,13 +112,14 @@
       'libcef_dll/resource.h',
       'libcef_dll/shutdown_checker.cc',
       'libcef_dll/shutdown_checker.h',
+      'libcef_dll/template_util.h',
       'libcef_dll/transfer_util.cc',
       'libcef_dll/transfer_util.h',
       'libcef_dll/wrapper_types.h',
     ],
     'libcef_dll_wrapper_sources_base': [
-      'libcef_dll/base/cef_atomicops_x86_gcc.cc',
+      'libcef_dll/base/cef_atomic_flag.cc',
-      'libcef_dll/base/cef_bind_helpers.cc',
+      'libcef_dll/base/cef_callback_helpers.cc',
       'libcef_dll/base/cef_callback_internal.cc',
       'libcef_dll/base/cef_lock.cc',
       'libcef_dll/base/cef_lock_impl.cc',
@@ -139,9 +137,9 @@
       'libcef_dll/cpptoc/cpptoc_scoped.h',
       'libcef_dll/ctocpp/ctocpp_ref_counted.h',
       'libcef_dll/ctocpp/ctocpp_scoped.h',
-      'libcef_dll/ptr_util.h',
       'libcef_dll/shutdown_checker.cc',
       'libcef_dll/shutdown_checker.h',
+      'libcef_dll/template_util.h',
       'libcef_dll/transfer_util.cc',
       'libcef_dll/transfer_util.h',
       'libcef_dll/wrapper_types.h',
@@ -179,6 +177,8 @@
       'tests/shared/browser/resource_util.h',
     ],
     'shared_sources_common': [
+      'tests/shared/common/binary_value_utils.cc',
+      'tests/shared/common/binary_value_utils.h',
       'tests/shared/common/client_app.cc',
       'tests/shared/common/client_app.h',
       'tests/shared/common/client_app_other.cc',
@@ -234,8 +234,6 @@
       'tests/cefclient/browser/client_types.h',
       'tests/cefclient/browser/dialog_test.cc',
       'tests/cefclient/browser/dialog_test.h',
-      'tests/cefclient/browser/drm_test.cc',
-      'tests/cefclient/browser/drm_test.h',
       'tests/cefclient/browser/image_cache.cc',
       'tests/cefclient/browser/image_cache.h',
       'tests/cefclient/browser/main_context.cc',
@@ -271,6 +269,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_controls.cc',
+      'tests/cefclient/browser/views_overlay_controls.h',
       'tests/cefclient/browser/views_style.cc',
       'tests/cefclient/browser/views_style.h',
       'tests/cefclient/browser/views_window.cc',
@@ -291,6 +291,8 @@
       'tests/cefclient/renderer/client_app_delegates_renderer.cc',
       'tests/cefclient/renderer/client_renderer.cc',
       'tests/cefclient/renderer/client_renderer.h',
+      'tests/cefclient/renderer/ipc_performance_test.cc',
+      'tests/cefclient/renderer/ipc_performance_test.h',
       'tests/cefclient/renderer/performance_test.cc',
       'tests/cefclient/renderer/performance_test.h',
       'tests/cefclient/renderer/performance_test_setup.h',
@@ -300,7 +302,7 @@
       'tests/cefclient/resources/binding.html',
       'tests/cefclient/resources/dialogs.html',
       'tests/cefclient/resources/draggable.html',
-      'tests/cefclient/resources/drm.html',
+      'tests/cefclient/resources/ipc_performance.html',
       'tests/cefclient/resources/localstorage.html',
       'tests/cefclient/resources/logo.png',
       'tests/cefclient/resources/media_router.html',
@@ -471,19 +473,27 @@
       'tests/ceftests/extensions/extension_test_handler.h',
       'tests/ceftests/extensions/view_unittest.cc',
       'tests/ceftests/file_util_unittest.cc',
+      'tests/ceftests/frame_handler_unittest.cc',
       'tests/ceftests/frame_unittest.cc',
       'tests/ceftests/image_unittest.cc',
       'tests/ceftests/image_util.cc',
       'tests/ceftests/image_util.h',
       'tests/ceftests/jsdialog_unittest.cc',
       'tests/ceftests/life_span_unittest.cc',
-      'tests/ceftests/message_router_unittest.cc',
+      'tests/ceftests/media_access_unittest.cc',
+      'tests/ceftests/message_router_harness_unittest.cc',
+      'tests/ceftests/message_router_multi_query_unittest.cc',
+      'tests/ceftests/message_router_single_query_unittest.cc',
+      'tests/ceftests/message_router_threshold_unittest.cc',
+      'tests/ceftests/message_router_unittest_utils.cc',
+      'tests/ceftests/message_router_unittest_utils.h',
       'tests/ceftests/navigation_unittest.cc',
       'tests/ceftests/os_rendering_unittest.cc',
       'tests/ceftests/osr_accessibility_unittest.cc',
       'tests/ceftests/osr_display_unittest.cc',
       'tests/ceftests/parser_unittest.cc',
-      'tests/ceftests/plugin_unittest.cc',
+      'tests/ceftests/pdf_viewer_unittest.cc',
+      'tests/ceftests/permission_prompt_unittest.cc',
       'tests/ceftests/preference_unittest.cc',
       'tests/ceftests/print_unittest.cc',
       'tests/ceftests/process_message_unittest.cc',
@@ -500,6 +510,8 @@
       'tests/ceftests/scheme_handler_unittest.cc',
       'tests/ceftests/scoped_temp_dir_unittest.cc',
       'tests/ceftests/server_unittest.cc',
+      'tests/ceftests/send_shared_process_message_unittest.cc',
+      "tests/ceftests/shared_process_message_unittest.cc",
       'tests/ceftests/stream_unittest.cc',
       'tests/ceftests/stream_resource_handler_unittest.cc',
       'tests/ceftests/string_unittest.cc',
@@ -564,9 +576,16 @@
       'tests/ceftests/cors_unittest.cc',
       'tests/ceftests/dom_unittest.cc',
       'tests/ceftests/frame_unittest.cc',
-      'tests/ceftests/message_router_unittest.cc',
+      'tests/ceftests/media_access_unittest.cc',
+      'tests/ceftests/message_router_harness_unittest.cc',
+      'tests/ceftests/message_router_multi_query_unittest.cc',
+      'tests/ceftests/message_router_single_query_unittest.cc',
+      'tests/ceftests/message_router_threshold_unittest.cc',
+      'tests/ceftests/message_router_unittest_utils.cc',
+      'tests/ceftests/message_router_unittest_utils.h',
       'tests/ceftests/navigation_unittest.cc',
-      'tests/ceftests/plugin_unittest.cc',
+      'tests/ceftests/pdf_viewer_unittest.cc',
+      'tests/ceftests/permission_prompt_unittest.cc',
       'tests/ceftests/preference_unittest.cc',
       'tests/ceftests/process_message_unittest.cc',
       'tests/ceftests/request_handler_unittest.cc',
@@ -576,6 +595,8 @@
       'tests/ceftests/routing_test_handler.cc',
       'tests/ceftests/routing_test_handler.h',
       'tests/ceftests/scheme_handler_unittest.cc',
+      'tests/ceftests/send_shared_process_message_unittest.cc',
+      "tests/ceftests/shared_process_message_unittest.cc",
       'tests/ceftests/urlrequest_unittest.cc',
       'tests/ceftests/test_handler.cc',
       'tests/ceftests/test_handler.h',

cmake/cef_variables.cmake.in

@@ -105,7 +105,7 @@ if(OS_LINUX)
     -fno-rtti                       # Disable real-time type information
     -fno-threadsafe-statics         # Don't generate thread-safe statics
     -fvisibility-inlines-hidden     # Give hidden visibility to inlined class member functions
-    -std=gnu++11                    # Use the C++11 language standard including GNU extensions
+    -std=c++14                      # Use the C++14 language standard
     -Wsign-compare                  # Warn about mixed signed/unsigned type comparisons
     )
   list(APPEND CEF_COMPILER_FLAGS_DEBUG
@@ -222,9 +222,11 @@ if(OS_LINUX)
     libcef.so
     libEGL.so
     libGLESv2.so
+    libvk_swiftshader.so
+    libvulkan.so.1
     snapshot_blob.bin
     v8_context_snapshot.bin
-    swiftshader
+    vk_swiftshader_icd.json
     )
 
   # List of CEF resource files.
@@ -274,7 +276,7 @@ if(OS_MAC)
     -fno-threadsafe-statics         # Don't generate thread-safe statics
     -fobjc-call-cxx-cdtors          # Call the constructor/destructor of C++ instance variables in ObjC objects
     -fvisibility-inlines-hidden     # Give hidden visibility to inlined class member functions
-    -std=gnu++11                    # Use the C++11 language standard including GNU extensions
+    -std=c++14                      # Use the C++14 language standard
     -Wno-narrowing                  # Don't warn about type narrowing
     -Wsign-compare                  # Warn about mixed signed/unsigned type comparisons
     )
@@ -312,7 +314,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 10.15 10.14 10.13 10.12 10.11)
+  foreach(OS_VERSION 10.15 10.14 10.13)
     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})
@@ -320,7 +322,7 @@ if(OS_MAC)
   endforeach()
 
   # Target SDK.
-  set(CEF_TARGET_SDK               "10.11")
+  set(CEF_TARGET_SDK               "10.13")
   list(APPEND CEF_COMPILER_FLAGS
     -mmacosx-version-min=${CEF_TARGET_SDK}
   )
@@ -407,6 +409,7 @@ if(OS_WINDOWS)
     /wd4100       # Ignore "unreferenced formal parameter" warning
     /wd4127       # Ignore "conditional expression is constant" warning
     /wd4244       # Ignore "conversion possible loss of data" warning
+    /wd4324       # Ignore "structure was padded due to alignment specifier" warning
     /wd4481       # Ignore "nonstandard extension used: override" warning
     /wd4512       # Ignore "assignment operator could not be generated" warning
     /wd4701       # Ignore "potentially uninitialized local variable" warning
@@ -445,6 +448,7 @@ if(OS_WINDOWS)
   # Standard libraries.
   set(CEF_STANDARD_LIBS
     comctl32.lib
+    gdi32.lib
     rpcrt4.lib
     shlwapi.lib
     ws2_32.lib
@@ -468,7 +472,9 @@ if(OS_WINDOWS)
     libGLESv2.dll
     snapshot_blob.bin
     v8_context_snapshot.bin
-    swiftshader
+    vk_swiftshader.dll
+    vk_swiftshader_icd.json
+    vulkan-1.dll
     )
 
   if(NOT PROJECT_ARCH STREQUAL "arm64")

include/base/cef_atomic_flag.h

@@ -0,0 +1,88 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_ATOMIC_FLAG_H_
+#define CEF_INCLUDE_BASE_CEF_ATOMIC_FLAG_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/synchronization/atomic_flag.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 <stdint.h>
+
+#include <atomic>
+
+#include "include/base/cef_thread_checker.h"
+
+namespace base {
+
+// A flag that can safely be set from one thread and read from other threads.
+//
+// This class IS NOT intended for synchronization between threads.
+class AtomicFlag {
+ public:
+  AtomicFlag();
+
+  AtomicFlag(const AtomicFlag&) = delete;
+  AtomicFlag& operator=(const AtomicFlag&) = delete;
+
+  ~AtomicFlag();
+
+  // Set the flag. Must always be called from the same thread.
+  void Set();
+
+  // Returns true iff the flag was set. If this returns true, the current thread
+  // is guaranteed to be synchronized with all memory operations on the thread
+  // which invoked Set() up until at least the first call to Set() on it.
+  bool IsSet() const {
+    // Inline here: this has a measurable performance impact on base::WeakPtr.
+    return flag_.load(std::memory_order_acquire) != 0;
+  }
+
+  // Resets the flag. Be careful when using this: callers might not expect
+  // IsSet() to return false after returning true once.
+  void UnsafeResetForTesting();
+
+ private:
+  std::atomic<uint_fast8_t> flag_{0};
+  base::ThreadChecker set_thread_checker_;
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_ATOMIC_FLAG_H_

include/base/cef_atomic_ref_count.h

@@ -43,120 +43,66 @@
 // When building CEF include the Chromium header directly.
 #include "base/atomic_ref_count.h"
 
-// Used when declaring a base::AtomicRefCount value. This is an object type with
-// Chromium headers.
-#define ATOMIC_DECLARATION (0)
-
-// Maintaining compatibility with AtompicRefCount* functions that were removed
-// from Chromium in http://crrev.com/ee96d561.
-namespace base {
-
-// Increment a reference count by 1.
-inline void AtomicRefCountInc(volatile AtomicRefCount* ptr) {
-  const_cast<AtomicRefCount*>(ptr)->Increment();
-}
-
-// Decrement a reference count by 1 and return whether the result is non-zero.
-// Insert barriers to ensure that state written before the reference count
-// became zero will be visible to a thread that has just made the count zero.
-inline bool AtomicRefCountDec(volatile AtomicRefCount* ptr) {
-  return const_cast<AtomicRefCount*>(ptr)->Decrement();
-}
-
-// Return whether the reference count is one.  If the reference count is used
-// in the conventional way, a refrerence count of 1 implies that the current
-// thread owns the reference and no other thread shares it.  This call performs
-// the test for a reference count of one, and performs the memory barrier
-// needed for the owning thread to act on the object, knowing that it has
-// exclusive access to the object.
-inline bool AtomicRefCountIsOne(volatile AtomicRefCount* ptr) {
-  return const_cast<AtomicRefCount*>(ptr)->IsOne();
-}
-
-// Return whether the reference count is zero.  With conventional object
-// referencing counting, the object will be destroyed, so the reference count
-// should never be zero.  Hence this is generally used for a debug check.
-inline bool AtomicRefCountIsZero(volatile AtomicRefCount* ptr) {
-  return const_cast<AtomicRefCount*>(ptr)->IsZero();
-}
-
-}  // namespace base
-
 #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_atomicops.h"
+#include <atomic>
-
-// Annotations are not currently supported.
-#define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
-#define ANNOTATE_HAPPENS_AFTER(obj)  /* empty */
-
-// Used when declaring a base::AtomicRefCount value. This is an integer/ptr type
-// with CEF headers.
-#define ATOMIC_DECLARATION = 0
 
 namespace base {
 
-typedef subtle::Atomic32 AtomicRefCount;
+class AtomicRefCount {
+ public:
+  constexpr AtomicRefCount() : ref_count_(0) {}
+  explicit constexpr AtomicRefCount(int initial_value)
+      : ref_count_(initial_value) {}
 
-// Increment a reference count by "increment", which must exceed 0.
+  // Increment a reference count.
-inline void AtomicRefCountIncN(volatile AtomicRefCount* ptr,
+  // Returns the previous value of the count.
-                               AtomicRefCount increment) {
+  int Increment() { return Increment(1); }
-  subtle::NoBarrier_AtomicIncrement(ptr, increment);
-}
 
-// Decrement a reference count by "decrement", which must exceed 0,
+  // Increment a reference count by "increment", which must exceed 0.
-// and return whether the result is non-zero.
+  // Returns the previous value of the count.
-// Insert barriers to ensure that state written before the reference count
+  int Increment(int increment) {
-// became zero will be visible to a thread that has just made the count zero.
+    return ref_count_.fetch_add(increment, std::memory_order_relaxed);
-inline bool AtomicRefCountDecN(volatile AtomicRefCount* ptr,
-                               AtomicRefCount decrement) {
-  ANNOTATE_HAPPENS_BEFORE(ptr);
-  bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0);
-  if (!res) {
-    ANNOTATE_HAPPENS_AFTER(ptr);
   }
-  return res;
-}
 
-// Increment a reference count by 1.
+  // Decrement a reference count, and return whether the result is non-zero.
-inline void AtomicRefCountInc(volatile AtomicRefCount* ptr) {
+  // Insert barriers to ensure that state written before the reference count
-  base::AtomicRefCountIncN(ptr, 1);
+  // became zero will be visible to a thread that has just made the count zero.
-}
+  bool Decrement() {
-
+    // TODO(jbroman): Technically this doesn't need to be an acquire operation
-// Decrement a reference count by 1 and return whether the result is non-zero.
+    // unless the result is 1 (i.e., the ref count did indeed reach zero).
-// Insert barriers to ensure that state written before the reference count
+    // However, there are toolchain issues that make that not work as well at
-// became zero will be visible to a thread that has just made the count zero.
+    // present (notably TSAN doesn't like it).
-inline bool AtomicRefCountDec(volatile AtomicRefCount* ptr) {
+    return ref_count_.fetch_sub(1, std::memory_order_acq_rel) != 1;
-  return base::AtomicRefCountDecN(ptr, 1);
-}
-
-// Return whether the reference count is one.  If the reference count is used
-// in the conventional way, a refrerence count of 1 implies that the current
-// thread owns the reference and no other thread shares it.  This call performs
-// the test for a reference count of one, and performs the memory barrier
-// needed for the owning thread to act on the object, knowing that it has
-// exclusive access to the object.
-inline bool AtomicRefCountIsOne(volatile AtomicRefCount* ptr) {
-  bool res = (subtle::Acquire_Load(ptr) == 1);
-  if (res) {
-    ANNOTATE_HAPPENS_AFTER(ptr);
   }
-  return res;
-}
 
-// Return whether the reference count is zero.  With conventional object
+  // Return whether the reference count is one.  If the reference count is used
-// referencing counting, the object will be destroyed, so the reference count
+  // in the conventional way, a refrerence count of 1 implies that the current
-// should never be zero.  Hence this is generally used for a debug check.
+  // thread owns the reference and no other thread shares it.  This call
-inline bool AtomicRefCountIsZero(volatile AtomicRefCount* ptr) {
+  // performs the test for a reference count of one, and performs the memory
-  bool res = (subtle::Acquire_Load(ptr) == 0);
+  // barrier needed for the owning thread to act on the object, knowing that it
-  if (res) {
+  // has exclusive access to the object.
-    ANNOTATE_HAPPENS_AFTER(ptr);
+  bool IsOne() const { return ref_count_.load(std::memory_order_acquire) == 1; }
+
+  // Return whether the reference count is zero.  With conventional object
+  // referencing counting, the object will be destroyed, so the reference count
+  // should never be zero.  Hence this is generally used for a debug check.
+  bool IsZero() const {
+    return ref_count_.load(std::memory_order_acquire) == 0;
   }
-  return res;
+
-}
+  // Returns the current reference count (with no barriers). This is subtle, and
+  // should be used only for debugging.
+  int SubtleRefCountForDebug() const {
+    return ref_count_.load(std::memory_order_relaxed);
+  }
+
+ private:
+  std::atomic_int ref_count_;
+};
 
 }  // namespace base
 

include/base/cef_atomicops.h

@@ -1,203 +0,0 @@
-// Copyright (c) 2014 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.
-
-// For atomic operations on reference counts, see cef_atomic_ref_count.h.
-
-// The routines exported by this module are subtle.  If you use them, even if
-// you get the code right, it will depend on careful reasoning about atomicity
-// and memory ordering; it will be less readable, and harder to maintain.  If
-// you plan to use these routines, you should have a good reason, such as solid
-// evidence that performance would otherwise suffer, or there being no
-// alternative.  You should assume only properties explicitly guaranteed by the
-// specifications in this file.  You are almost certainly _not_ writing code
-// just for the x86; if you assume x86 semantics, x86 hardware bugs and
-// implementations on other archtectures will cause your code to break.  If you
-// do not know what you are doing, avoid these routines, and use a Mutex.
-//
-// It is incorrect to make direct assignments to/from an atomic variable.
-// You should use one of the Load or Store routines.  The NoBarrier
-// versions are provided when no barriers are needed:
-//   NoBarrier_Store()
-//   NoBarrier_Load()
-// Although there are currently no compiler enforcement, you are encouraged
-// to use these.
-//
-
-#ifndef CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
-#define CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_
-#pragma once
-
-#if defined(BASE_ATOMICOPS_H_)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-#include "base/atomicops.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 <stdint.h>
-
-#include "include/base/cef_build.h"
-
-#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
-// windows.h #defines this (only on x64). This causes problems because the
-// public API also uses MemoryBarrier at the public name for this fence. So, on
-// X64, undef it, and call its documented
-// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
-// implementation directly.
-#undef MemoryBarrier
-#endif
-
-namespace base {
-namespace subtle {
-
-typedef int32_t Atomic32;
-#ifdef ARCH_CPU_64_BITS
-// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
-// means Atomic64 and AtomicWord should be the same type on 64-bit.
-#if defined(__ILP32__) || defined(OS_NACL)
-// NaCl's intptr_t is not actually 64-bits on 64-bit!
-// http://code.google.com/p/nativeclient/issues/detail?id=1162
-typedef int64_t Atomic64;
-#else
-typedef intptr_t Atomic64;
-#endif
-#endif
-
-// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
-// Atomic64 routines below, depending on your architecture.
-typedef intptr_t AtomicWord;
-
-// Atomically execute:
-//      result = *ptr;
-//      if (*ptr == old_value)
-//        *ptr = new_value;
-//      return result;
-//
-// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
-// Always return the old value of "*ptr"
-//
-// This routine implies no memory barriers.
-Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                  Atomic32 old_value,
-                                  Atomic32 new_value);
-
-// Atomically store new_value into *ptr, returning the previous value held in
-// *ptr.  This routine implies no memory barriers.
-Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
-
-// Atomically increment *ptr by "increment".  Returns the new value of
-// *ptr with the increment applied.  This routine implies no memory barriers.
-Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
-
-Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
-
-// These following lower-level operations are typically useful only to people
-// implementing higher-level synchronization operations like spinlocks,
-// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
-// a store with appropriate memory-ordering instructions.  "Acquire" operations
-// ensure that no later memory access can be reordered ahead of the operation.
-// "Release" operations ensure that no previous memory access can be reordered
-// after the operation.  "Barrier" operations have both "Acquire" and "Release"
-// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
-// access.
-Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                Atomic32 old_value,
-                                Atomic32 new_value);
-Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                Atomic32 old_value,
-                                Atomic32 new_value);
-
-void MemoryBarrier();
-void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
-void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
-void Release_Store(volatile Atomic32* ptr, Atomic32 value);
-
-Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
-Atomic32 Acquire_Load(volatile const Atomic32* ptr);
-Atomic32 Release_Load(volatile const Atomic32* ptr);
-
-// 64-bit atomic operations (only available on 64-bit processors).
-#ifdef ARCH_CPU_64_BITS
-Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                  Atomic64 old_value,
-                                  Atomic64 new_value);
-Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
-Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
-Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
-
-Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                Atomic64 old_value,
-                                Atomic64 new_value);
-Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                Atomic64 old_value,
-                                Atomic64 new_value);
-void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
-void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
-void Release_Store(volatile Atomic64* ptr, Atomic64 value);
-Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
-Atomic64 Acquire_Load(volatile const Atomic64* ptr);
-Atomic64 Release_Load(volatile const Atomic64* ptr);
-#endif  // ARCH_CPU_64_BITS
-
-}  // namespace subtle
-}  // namespace base
-
-// Include our platform specific implementation.
-#if defined(OS_WIN) && defined(COMPILER_MSVC) && defined(ARCH_CPU_X86_FAMILY)
-#include "include/base/internal/cef_atomicops_x86_msvc.h"
-#elif defined(OS_WIN) && (defined(__ARM_ARCH_ISA_A64) || defined(_M_ARM64))
-#include "include/base/internal/cef_atomicops_arm64_msvc.h"
-#elif defined(OS_MAC)
-#include "include/base/internal/cef_atomicops_mac.h"
-#elif defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY)
-#include "include/base/internal/cef_atomicops_x86_gcc.h"
-#elif defined(COMPILER_GCC) && defined(__ARM_ARCH_ISA_A64)
-#include "include/base/internal/cef_atomicops_arm64_gcc.h"
-#elif defined(COMPILER_GCC) && defined(__ARM_ARCH)
-#include "include/base/internal/cef_atomicops_arm_gcc.h"
-#else
-#error "Atomic operations are not supported on your platform"
-#endif
-
-// On some platforms we need additional declarations to make
-// AtomicWord compatible with our other Atomic* types.
-#if defined(OS_MAC) || defined(OS_OPENBSD)
-#include "include/base/internal/cef_atomicops_atomicword_compat.h"
-#endif
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_ATOMICOPS_H_

include/base/cef_auto_reset.h

@@ -0,0 +1,89 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// base::AutoReset<> is useful for setting a variable to a new value only within
+// a particular scope. An base::AutoReset<> object resets a variable to its
+// original value upon destruction, making it an alternative to writing
+// "var = false;" or "var = old_val;" at all of a block's exit points.
+//
+// This should be obvious, but note that an base::AutoReset<> instance should
+// have a shorter lifetime than its scoped_variable, to prevent invalid memory
+// writes when the base::AutoReset<> object is destroyed.
+
+#ifndef CEF_INCLUDE_BASE_CEF_AUTO_RESET_H_
+#define CEF_INCLUDE_BASE_CEF_AUTO_RESET_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/auto_reset.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 <utility>
+
+namespace base {
+
+template <typename T>
+class AutoReset {
+ public:
+  template <typename U>
+  AutoReset(T* scoped_variable, U&& new_value)
+      : scoped_variable_(scoped_variable),
+        original_value_(
+            std::exchange(*scoped_variable_, std::forward<U>(new_value))) {}
+
+  AutoReset(AutoReset&& other)
+      : scoped_variable_(std::exchange(other.scoped_variable_, nullptr)),
+        original_value_(std::move(other.original_value_)) {}
+
+  AutoReset& operator=(AutoReset&& rhs) {
+    scoped_variable_ = std::exchange(rhs.scoped_variable_, nullptr);
+    original_value_ = std::move(rhs.original_value_);
+    return *this;
+  }
+
+  ~AutoReset() {
+    if (scoped_variable_)
+      *scoped_variable_ = std::move(original_value_);
+  }
+
+ private:
+  T* scoped_variable_;
+  T original_value_;
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_AUTO_RESET_H_

include/base/cef_bind.h

@@ -28,16 +28,47 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// Overview:
+// base::BindOnce() and base::BindRepeating() are helpers for creating
+// base::OnceCallback and base::RepeatingCallback objects respectively.
+//
+// For a runnable object of n-arity, the base::Bind*() family allows partial
+// application of the first m arguments. The remaining n - m arguments must be
+// passed when invoking the callback with Run().
+//
+//   // The first argument is bound at callback creation; the remaining
+//   // two must be passed when calling Run() on the callback object.
+//   base::OnceCallback<long(int, long)> cb = base::BindOnce(
+//       [](short x, int y, long z) { return x * y * z; }, 42);
+//
+// When binding to a method, the receiver object must also be specified at
+// callback creation time. When Run() is invoked, the method will be invoked on
+// the specified receiver object.
+//
+//   class C : public base::RefCounted<C> { void F(); };
+//   auto instance = base::MakeRefCounted<C>();
+//   auto cb = base::BindOnce(&C::F, instance);
+//   std::move(cb).Run();  // Identical to instance->F()
+//
+// See //docs/callback.md for the full documentation.
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// If you're reading the implementation, before proceeding further, you should
+// read the top comment of base/internal/cef_bind_internal.h for a definition of
+// common terms and concepts.
+
 #ifndef CEF_INCLUDE_BASE_CEF_BIND_H_
 #define CEF_INCLUDE_BASE_CEF_BIND_H_
 #pragma once
 
-#if defined(BASE_BIND_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/bind.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -45,529 +76,275 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include "include/base/internal/cef_bind_internal.h"
+#include <functional>
-#include "include/base/internal/cef_callback_internal.h"
+#include <memory>
+#include <type_traits>
+#include <utility>
 
-// -----------------------------------------------------------------------------
+#include "include/base/cef_build.h"
-// Usage documentation
+#include "include/base/cef_compiler_specific.h"
-// -----------------------------------------------------------------------------
+#include "include/base/cef_template_util.h"
-//
+#include "include/base/internal/cef_bind_internal.h"
-// See base/cef_callback.h for documentation.
+
-//
+#if defined(OS_APPLE) && !HAS_FEATURE(objc_arc)
-//
+#include "include/base/internal/cef_scoped_block_mac.h"
-// -----------------------------------------------------------------------------
+#endif
-// Implementation notes
-// -----------------------------------------------------------------------------
-//
-// If you're reading the implementation, before proceeding further, you should
-// read the top comment of base/bind_internal.h for a definition of common
-// terms and concepts.
-//
-// RETURN TYPES
-//
-// Though Bind()'s result is meant to be stored in a Callback<> type, it
-// cannot actually return the exact type without requiring a large amount
-// of extra template specializations. The problem is that in order to
-// discern the correct specialization of Callback<>, Bind would need to
-// unwrap the function signature to determine the signature's arity, and
-// whether or not it is a method.
-//
-// Each unique combination of (arity, function_type, num_prebound) where
-// function_type is one of {function, method, const_method} would require
-// one specialization.  We eventually have to do a similar number of
-// specializations anyways in the implementation (see the Invoker<>,
-// classes).  However, it is avoidable in Bind if we return the result
-// via an indirection like we do below.
-//
-// TODO(ajwong): We might be able to avoid this now, but need to test.
-//
-// It is possible to move most of the COMPILE_ASSERT asserts into BindState<>,
-// but it feels a little nicer to have the asserts here so people do not
-// need to crack open bind_internal.h.  On the other hand, it makes Bind()
-// harder to read.
 
 namespace base {
 
-template <typename Functor>
+// Bind as OnceCallback.
-base::Callback<typename cef_internal::BindState<
+template <typename Functor, typename... Args>
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+inline OnceCallback<internal::MakeUnboundRunType<Functor, Args...>> BindOnce(
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+    Functor&& functor,
-    void()>::UnboundRunType>
+    Args&&... args) {
-Bind(Functor functor) {
+  static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
-  // Typedefs for how to store and run the functor.
+                    (std::is_rvalue_reference<Functor&&>() &&
-  typedef
+                     !std::is_const<std::remove_reference_t<Functor>>()),
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+                "BindOnce requires non-const rvalue for OnceCallback binding."
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
+                " I.e.: base::BindOnce(std::move(callback)).");
+  static_assert(
+      conjunction<
+          internal::AssertBindArgIsNotBasePassed<std::decay_t<Args>>...>::value,
+      "Use std::move() instead of base::Passed() with base::BindOnce()");
 
-  typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;
+  return internal::BindImpl<OnceCallback>(std::forward<Functor>(functor),
-
+                                          std::forward<Args>(args)...);
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor)));
 }
 
-template <typename Functor, typename P1>
+// Bind as RepeatingCallback.
-base::Callback<typename cef_internal::BindState<
+template <typename Functor, typename... Args>
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+inline RepeatingCallback<internal::MakeUnboundRunType<Functor, Args...>>
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+BindRepeating(Functor&& functor, Args&&... args) {
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>::
+  static_assert(
-                   UnboundRunType>
+      !internal::IsOnceCallback<std::decay_t<Functor>>(),
-Bind(Functor functor, const P1& p1) {
+      "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
 
-  // Use RunnableType::RunType instead of RunType above because our
+  return internal::BindImpl<RepeatingCallback>(std::forward<Functor>(functor),
-  // checks should below for bound references need to know what the actual
+                                               std::forward<Args>(args)...);
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1));
 }
 
-template <typename Functor, typename P1, typename P2>
+// Special cases for binding to a base::Callback without extra bound arguments.
-base::Callback<typename cef_internal::BindState<
+// We CHECK() the validity of callback to guard against null pointers
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+// accidentally ending up in posted tasks, causing hard-to-debug crashes.
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+template <typename Signature>
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+OnceCallback<Signature> BindOnce(OnceCallback<Signature> callback) {
-         typename cef_internal::CallbackParamTraits<P2>::StorageType)>::
+  CHECK(callback);
-                   UnboundRunType>
+  return callback;
-Bind(Functor functor, const P1& p1, const P2& p2) {
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1, p2));
 }
 
-template <typename Functor, typename P1, typename P2, typename P3>
+template <typename Signature>
-base::Callback<typename cef_internal::BindState<
+OnceCallback<Signature> BindOnce(RepeatingCallback<Signature> callback) {
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+  CHECK(callback);
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+  return callback;
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-         typename cef_internal::CallbackParamTraits<P2>::StorageType,
-         typename cef_internal::CallbackParamTraits<P3>::StorageType)>::
-                   UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A3Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
-                 p3_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType,
-           typename cef_internal::CallbackParamTraits<P3>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
 }
 
-template <typename Functor, typename P1, typename P2, typename P3, typename P4>
+template <typename Signature>
-base::Callback<typename cef_internal::BindState<
+RepeatingCallback<Signature> BindRepeating(
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+    RepeatingCallback<Signature> callback) {
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+  CHECK(callback);
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+  return callback;
-         typename cef_internal::CallbackParamTraits<P2>::StorageType,
-         typename cef_internal::CallbackParamTraits<P3>::StorageType,
-         typename cef_internal::CallbackParamTraits<P4>::StorageType)>::
-                   UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A4Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
-                 p3_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
-                 p4_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType,
-           typename cef_internal::CallbackParamTraits<P3>::StorageType,
-           typename cef_internal::CallbackParamTraits<P4>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4));
 }
 
-template <typename Functor,
+// Unretained() allows binding a non-refcounted class, and to disable
-          typename P1,
+// refcounting on arguments that are refcounted objects.
-          typename P2,
+//
-          typename P3,
+// EXAMPLE OF Unretained():
-          typename P4,
+//
-          typename P5>
+//   class Foo {
-base::Callback<typename cef_internal::BindState<
+//    public:
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+//     void func() { cout << "Foo:f" << endl; }
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+//   };
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+//
-         typename cef_internal::CallbackParamTraits<P2>::StorageType,
+//   // In some function somewhere.
-         typename cef_internal::CallbackParamTraits<P3>::StorageType,
+//   Foo foo;
-         typename cef_internal::CallbackParamTraits<P4>::StorageType,
+//   OnceClosure foo_callback =
-         typename cef_internal::CallbackParamTraits<P5>::StorageType)>::
+//       BindOnce(&Foo::func, Unretained(&foo));
-                   UnboundRunType>
+//   std::move(foo_callback).Run();  // Prints "Foo:f".
-Bind(Functor functor,
+//
-     const P1& p1,
+// Without the Unretained() wrapper on |&foo|, the above call would fail
-     const P2& p2,
+// to compile because Foo does not support the AddRef() and Release() methods.
-     const P3& p3,
+template <typename T>
-     const P4& p4,
+inline internal::UnretainedWrapper<T> Unretained(T* o) {
-     const P5& p5) {
+  return internal::UnretainedWrapper<T>(o);
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A5Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
-                 p3_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
-                 p4_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
-                 p5_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType,
-           typename cef_internal::CallbackParamTraits<P3>::StorageType,
-           typename cef_internal::CallbackParamTraits<P4>::StorageType,
-           typename cef_internal::CallbackParamTraits<P5>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
 }
 
-template <typename Functor,
+// RetainedRef() accepts a ref counted object and retains a reference to it.
-          typename P1,
+// When the callback is called, the object is passed as a raw pointer.
-          typename P2,
+//
-          typename P3,
+// EXAMPLE OF RetainedRef():
-          typename P4,
+//
-          typename P5,
+//    void foo(RefCountedBytes* bytes) {}
-          typename P6>
+//
-base::Callback<typename cef_internal::BindState<
+//    scoped_refptr<RefCountedBytes> bytes = ...;
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+//    OnceClosure callback = BindOnce(&foo, base::RetainedRef(bytes));
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+//    std::move(callback).Run();
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+//
-         typename cef_internal::CallbackParamTraits<P2>::StorageType,
+// Without RetainedRef, the scoped_refptr would try to implicitly convert to
-         typename cef_internal::CallbackParamTraits<P3>::StorageType,
+// a raw pointer and fail compilation:
-         typename cef_internal::CallbackParamTraits<P4>::StorageType,
+//
-         typename cef_internal::CallbackParamTraits<P5>::StorageType,
+//    OnceClosure callback = BindOnce(&foo, bytes); // ERROR!
-         typename cef_internal::CallbackParamTraits<P6>::StorageType)>::
+template <typename T>
-                   UnboundRunType>
+inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
-Bind(Functor functor,
+  return internal::RetainedRefWrapper<T>(o);
-     const P1& p1,
+}
-     const P2& p2,
+template <typename T>
-     const P3& p3,
+inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
-     const P4& p4,
+  return internal::RetainedRefWrapper<T>(std::move(o));
-     const P5& p5,
-     const P6& p6) {
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A6Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
-                 p3_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
-                 p4_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
-                 p5_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
-                 p6_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType,
-           typename cef_internal::CallbackParamTraits<P3>::StorageType,
-           typename cef_internal::CallbackParamTraits<P4>::StorageType,
-           typename cef_internal::CallbackParamTraits<P5>::StorageType,
-           typename cef_internal::CallbackParamTraits<P6>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(new BindState(
-      cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
 }
 
-template <typename Functor,
+// Owned() transfers ownership of an object to the callback resulting from
-          typename P1,
+// bind; the object will be deleted when the callback is deleted.
-          typename P2,
+//
-          typename P3,
+// EXAMPLE OF Owned():
-          typename P4,
+//
-          typename P5,
+//   void foo(int* arg) { cout << *arg << endl }
-          typename P6,
+//
-          typename P7>
+//   int* pn = new int(1);
-base::Callback<typename cef_internal::BindState<
+//   RepeatingClosure foo_callback = BindRepeating(&foo, Owned(pn));
-    typename cef_internal::FunctorTraits<Functor>::RunnableType,
+//
-    typename cef_internal::FunctorTraits<Functor>::RunType,
+//   foo_callback.Run();  // Prints "1"
-    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
+//   foo_callback.Run();  // Prints "1"
-         typename cef_internal::CallbackParamTraits<P2>::StorageType,
+//   *pn = 2;
-         typename cef_internal::CallbackParamTraits<P3>::StorageType,
+//   foo_callback.Run();  // Prints "2"
-         typename cef_internal::CallbackParamTraits<P4>::StorageType,
+//
-         typename cef_internal::CallbackParamTraits<P5>::StorageType,
+//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
-         typename cef_internal::CallbackParamTraits<P6>::StorageType,
+//                          // |foo_callback| goes out of scope.
-         typename cef_internal::CallbackParamTraits<P7>::StorageType)>::
+//
-                   UnboundRunType>
+// Without Owned(), someone would have to know to delete |pn| when the last
-Bind(Functor functor,
+// reference to the callback is deleted.
-     const P1& p1,
+template <typename T>
-     const P2& p2,
+inline internal::OwnedWrapper<T> Owned(T* o) {
-     const P3& p3,
+  return internal::OwnedWrapper<T>(o);
-     const P4& p4,
-     const P5& p5,
-     const P6& p6,
-     const P7& p7) {
-  // Typedefs for how to store and run the functor.
-  typedef
-      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
-  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
-
-  // Use RunnableType::RunType instead of RunType above because our
-  // checks should below for bound references need to know what the actual
-  // functor is going to interpret the argument as.
-  typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
-      BoundFunctorTraits;
-
-  // Do not allow binding a non-const reference parameter. Non-const reference
-  // parameters are disallowed by the Google style guide.  Also, binding a
-  // non-const reference parameter can make for subtle bugs because the
-  // invoked function will receive a reference to the stored copy of the
-  // argument and not the original.
-  COMPILE_ASSERT(
-      !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ||
-        is_non_const_reference<typename BoundFunctorTraits::A7Type>::value),
-      do_not_bind_functions_with_nonconst_ref);
-
-  // For methods, we need to be careful for parameter 1.  We do not require
-  // a scoped_refptr because BindState<> itself takes care of AddRef() for
-  // methods. We also disallow binding of an array as the method's target
-  // object.
-  COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
-                 p1_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
-                     !is_array<P1>::value,
-                 first_bound_argument_to_method_cannot_be_array);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
-                 p2_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
-                 p3_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
-                 p4_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
-                 p5_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
-                 p6_is_refcounted_type_and_needs_scoped_refptr);
-  COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
-                 p7_is_refcounted_type_and_needs_scoped_refptr);
-  typedef cef_internal::BindState<
-      RunnableType, RunType,
-      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-           typename cef_internal::CallbackParamTraits<P2>::StorageType,
-           typename cef_internal::CallbackParamTraits<P3>::StorageType,
-           typename cef_internal::CallbackParamTraits<P4>::StorageType,
-           typename cef_internal::CallbackParamTraits<P5>::StorageType,
-           typename cef_internal::CallbackParamTraits<P6>::StorageType,
-           typename cef_internal::CallbackParamTraits<P7>::StorageType)>
-      BindState;
-
-  return Callback<typename BindState::UnboundRunType>(new BindState(
-      cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, p7));
 }
 
+template <typename T, typename Deleter>
+inline internal::OwnedWrapper<T, Deleter> Owned(
+    std::unique_ptr<T, Deleter>&& ptr) {
+  return internal::OwnedWrapper<T, Deleter>(std::move(ptr));
+}
+
+// OwnedRef() stores an object in the callback resulting from
+// bind and passes a reference to the object to the bound function.
+//
+// EXAMPLE OF OwnedRef():
+//
+//   void foo(int& arg) { cout << ++arg << endl }
+//
+//   int counter = 0;
+//   RepeatingClosure foo_callback = BindRepeating(&foo, OwnedRef(counter));
+//
+//   foo_callback.Run();  // Prints "1"
+//   foo_callback.Run();  // Prints "2"
+//   foo_callback.Run();  // Prints "3"
+//
+//   cout << counter;     // Prints "0", OwnedRef creates a copy of counter.
+//
+//  Supports OnceCallbacks as well, useful to pass placeholder arguments:
+//
+//   void bar(int& ignore, const std::string& s) { cout << s << endl }
+//
+//   OnceClosure bar_callback = BindOnce(&bar, OwnedRef(0), "Hello");
+//
+//   std::move(bar_callback).Run(); // Prints "Hello"
+//
+// Without OwnedRef() it would not be possible to pass a mutable reference to an
+// object owned by the callback.
+template <typename T>
+internal::OwnedRefWrapper<std::decay_t<T>> OwnedRef(T&& t) {
+  return internal::OwnedRefWrapper<std::decay_t<T>>(std::forward<T>(t));
+}
+
+// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
+// through a RepeatingCallback. Logically, this signifies a destructive transfer
+// of the state of the argument into the target function. Invoking
+// RepeatingCallback::Run() twice on a callback that was created with a Passed()
+// argument will CHECK() because the first invocation would have already
+// transferred ownership to the target function.
+//
+// Note that Passed() is not necessary with BindOnce(), as std::move() does the
+// same thing. Avoid Passed() in favor of std::move() with BindOnce().
+//
+// EXAMPLE OF Passed():
+//
+//   void TakesOwnership(std::unique_ptr<Foo> arg) { }
+//   std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
+//   }
+//
+//   auto f = std::make_unique<Foo>();
+//
+//   // |cb| is given ownership of Foo(). |f| is now NULL.
+//   // You can use std::move(f) in place of &f, but it's more verbose.
+//   RepeatingClosure cb = BindRepeating(&TakesOwnership, Passed(&f));
+//
+//   // Run was never called so |cb| still owns Foo() and deletes
+//   // it on Reset().
+//   cb.Reset();
+//
+//   // |cb| is given a new Foo created by CreateFoo().
+//   cb = BindRepeating(&TakesOwnership, Passed(CreateFoo()));
+//
+//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
+//   // no longer owns Foo() and, if reset, would not delete Foo().
+//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
+//   cb.Run();  // This CHECK()s since Foo() already been used once.
+//
+// We offer 2 syntaxes for calling Passed(). The first takes an rvalue and is
+// best suited for use with the return value of a function or other temporary
+// rvalues. The second takes a pointer to the scoper and is just syntactic sugar
+// to avoid having to write Passed(std::move(scoper)).
+//
+// Both versions of Passed() prevent T from being an lvalue reference. The first
+// via use of enable_if, and the second takes a T* which will not bind to T&.
+template <typename T,
+          std::enable_if_t<!std::is_lvalue_reference<T>::value>* = nullptr>
+inline internal::PassedWrapper<T> Passed(T&& scoper) {
+  return internal::PassedWrapper<T>(std::move(scoper));
+}
+template <typename T>
+inline internal::PassedWrapper<T> Passed(T* scoper) {
+  return internal::PassedWrapper<T>(std::move(*scoper));
+}
+
+// IgnoreResult() is used to adapt a function or callback with a return type to
+// one with a void return. This is most useful if you have a function with,
+// say, a pesky ignorable bool return that you want to use with PostTask or
+// something else that expect a callback with a void return.
+//
+// EXAMPLE OF IgnoreResult():
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//
+//   // Assign to a callback with a void return type.
+//   OnceCallback<void(int)> cb = BindOnce(IgnoreResult(&DoSomething));
+//   std::move(cb).Run(1);  // Prints "1".
+//
+//   // Prints "2" on |ml|.
+//   ml->PostTask(FROM_HERE, BindOnce(IgnoreResult(&DoSomething), 2);
+template <typename T>
+inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
+  return internal::IgnoreResultHelper<T>(std::move(data));
+}
+
+#if defined(OS_APPLE) && !HAS_FEATURE(objc_arc)
+
+// RetainBlock() is used to adapt an Objective-C block when Automated Reference
+// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the
+// BindOnce and BindRepeating already support blocks then.
+//
+// EXAMPLE OF RetainBlock():
+//
+//   // Wrap the block and bind it to a callback.
+//   OnceCallback<void(int)> cb =
+//       BindOnce(RetainBlock(^(int n) { NSLog(@"%d", n); }));
+//   std::move(cb).Run(1);  // Logs "1".
+template <typename R, typename... Args>
+base::mac::ScopedBlock<R (^)(Args...)> RetainBlock(R (^block)(Args...)) {
+  return base::mac::ScopedBlock<R (^)(Args...)>(block,
+                                                base::scoped_policy::RETAIN);
+}
+
+#endif  // defined(OS_APPLE) && !HAS_FEATURE(objc_arc)
+
 }  // namespace base
 
 #endif  // !USING_CHROMIUM_INCLUDES

include/base/cef_bind_helpers.h

@@ -1,579 +0,0 @@
-// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2011
-// Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// This defines a set of argument wrappers and related factory methods that
-// can be used specify the refcounting and reference semantics of arguments
-// that are bound by the Bind() function in base/bind.h.
-//
-// It also defines a set of simple functions and utilities that people want
-// when using Callback<> and Bind().
-//
-//
-// ARGUMENT BINDING WRAPPERS
-//
-// The wrapper functions are base::Unretained(), base::Owned(), base::Passed(),
-// base::ConstRef(), and base::IgnoreResult().
-//
-// Unretained() allows Bind() to bind a non-refcounted class, and to disable
-// refcounting on arguments that are refcounted objects.
-//
-// Owned() transfers ownership of an object to the Callback resulting from
-// bind; the object will be deleted when the Callback is deleted.
-//
-// Passed() is for transferring movable-but-not-copyable types (eg. scoped_ptr)
-// through a Callback. Logically, this signifies a destructive transfer of
-// the state of the argument into the target function.  Invoking
-// Callback::Run() twice on a Callback that was created with a Passed()
-// argument will CHECK() because the first invocation would have already
-// transferred ownership to the target function.
-//
-// ConstRef() allows binding a constant reference to an argument rather
-// than a copy.
-//
-// IgnoreResult() is used to adapt a function or Callback with a return type to
-// one with a void return. This is most useful if you have a function with,
-// say, a pesky ignorable bool return that you want to use with PostTask or
-// something else that expect a Callback with a void return.
-//
-// EXAMPLE OF Unretained():
-//
-//   class Foo {
-//    public:
-//     void func() { cout << "Foo:f" << endl; }
-//   };
-//
-//   // In some function somewhere.
-//   Foo foo;
-//   Closure foo_callback =
-//       Bind(&Foo::func, Unretained(&foo));
-//   foo_callback.Run();  // Prints "Foo:f".
-//
-// Without the Unretained() wrapper on |&foo|, the above call would fail
-// to compile because Foo does not support the AddRef() and Release() methods.
-//
-//
-// EXAMPLE OF Owned():
-//
-//   void foo(int* arg) { cout << *arg << endl }
-//
-//   int* pn = new int(1);
-//   Closure foo_callback = Bind(&foo, Owned(pn));
-//
-//   foo_callback.Run();  // Prints "1"
-//   foo_callback.Run();  // Prints "1"
-//   *n = 2;
-//   foo_callback.Run();  // Prints "2"
-//
-//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
-//                          // |foo_callback| goes out of scope.
-//
-// Without Owned(), someone would have to know to delete |pn| when the last
-// reference to the Callback is deleted.
-//
-//
-// EXAMPLE OF ConstRef():
-//
-//   void foo(int arg) { cout << arg << endl }
-//
-//   int n = 1;
-//   Closure no_ref = Bind(&foo, n);
-//   Closure has_ref = Bind(&foo, ConstRef(n));
-//
-//   no_ref.Run();  // Prints "1"
-//   has_ref.Run();  // Prints "1"
-//
-//   n = 2;
-//   no_ref.Run();  // Prints "1"
-//   has_ref.Run();  // Prints "2"
-//
-// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
-// its bound callbacks.
-//
-//
-// EXAMPLE OF IgnoreResult():
-//
-//   int DoSomething(int arg) { cout << arg << endl; }
-//
-//   // Assign to a Callback with a void return type.
-//   Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
-//   cb->Run(1);  // Prints "1".
-//
-//   // Prints "1" on |ml|.
-//   ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
-//
-//
-// EXAMPLE OF Passed():
-//
-//   void TakesOwnership(scoped_ptr<Foo> arg) { }
-//   scoped_ptr<Foo> CreateFoo() { return scoped_ptr<Foo>(new Foo()); }
-//
-//   scoped_ptr<Foo> f(new Foo());
-//
-//   // |cb| is given ownership of Foo(). |f| is now NULL.
-//   // You can use f.Pass() in place of &f, but it's more verbose.
-//   Closure cb = Bind(&TakesOwnership, Passed(&f));
-//
-//   // Run was never called so |cb| still owns Foo() and deletes
-//   // it on Reset().
-//   cb.Reset();
-//
-//   // |cb| is given a new Foo created by CreateFoo().
-//   cb = Bind(&TakesOwnership, Passed(CreateFoo()));
-//
-//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
-//   // no longer owns Foo() and, if reset, would not delete Foo().
-//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
-//   cb.Run();  // This CHECK()s since Foo() already been used once.
-//
-// Passed() is particularly useful with PostTask() when you are transferring
-// ownership of an argument into a task, but don't necessarily know if the
-// task will always be executed. This can happen if the task is cancellable
-// or if it is posted to a MessageLoopProxy.
-//
-//
-// SIMPLE FUNCTIONS AND UTILITIES.
-//
-//   DoNothing() - Useful for creating a Closure that does nothing when called.
-//   DeletePointer<T>() - Useful for creating a Closure that will delete a
-//                        pointer when invoked. Only use this when necessary.
-//                        In most cases MessageLoop::DeleteSoon() is a better
-//                        fit.
-
-#ifndef CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
-#define CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_
-#pragma once
-
-#if defined(BASE_BIND_HELPERS_H_)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-#include "base/bind_helpers.h"
-#else  // !USING_CHROMIUM_INCLUDES
-// The following is substantially similar to the Chromium implementation.
-// If the Chromium implementation diverges the below implementation should be
-// updated to match.
-
-#include "include/base/cef_basictypes.h"
-#include "include/base/cef_callback.h"
-#include "include/base/cef_template_util.h"
-#include "include/base/cef_weak_ptr.h"
-
-namespace base {
-namespace cef_internal {
-
-// Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
-// for the existence of AddRef() and Release() functions of the correct
-// signature.
-//
-// http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
-// http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
-// http://stackoverflow.com/questions/4358584/sfinae-approach-comparison
-// http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions
-//
-// The last link in particular show the method used below.
-//
-// For SFINAE to work with inherited methods, we need to pull some extra tricks
-// with multiple inheritance.  In the more standard formulation, the overloads
-// of Check would be:
-//
-//   template <typename C>
-//   Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*);
-//
-//   template <typename C>
-//   No NotTheCheckWeWant(...);
-//
-//   static const bool value = sizeof(NotTheCheckWeWant<T>(0)) == sizeof(Yes);
-//
-// The problem here is that template resolution will not match
-// C::TargetFunc if TargetFunc does not exist directly in C.  That is, if
-// TargetFunc in inherited from an ancestor, &C::TargetFunc will not match,
-// |value| will be false.  This formulation only checks for whether or
-// not TargetFunc exist directly in the class being introspected.
-//
-// To get around this, we play a dirty trick with multiple inheritance.
-// First, We create a class BaseMixin that declares each function that we
-// want to probe for.  Then we create a class Base that inherits from both T
-// (the class we wish to probe) and BaseMixin.  Note that the function
-// signature in BaseMixin does not need to match the signature of the function
-// we are probing for; thus it's easiest to just use void(void).
-//
-// Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an
-// ambiguous resolution between BaseMixin and T.  This lets us write the
-// following:
-//
-//   template <typename C>
-//   No GoodCheck(Helper<&C::TargetFunc>*);
-//
-//   template <typename C>
-//   Yes GoodCheck(...);
-//
-//   static const bool value = sizeof(GoodCheck<Base>(0)) == sizeof(Yes);
-//
-// Notice here that the variadic version of GoodCheck() returns Yes here
-// instead of No like the previous one. Also notice that we calculate |value|
-// by specializing GoodCheck() on Base instead of T.
-//
-// We've reversed the roles of the variadic, and Helper overloads.
-// GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid
-// substitution if T::TargetFunc exists. Thus GoodCheck<Base>(0) will resolve
-// to the variadic version if T has TargetFunc.  If T::TargetFunc does not
-// exist, then &C::TargetFunc is not ambiguous, and the overload resolution
-// will prefer GoodCheck(Helper<&C::TargetFunc>*).
-//
-// This method of SFINAE will correctly probe for inherited names, but it cannot
-// typecheck those names.  It's still a good enough sanity check though.
-//
-// Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.
-//
-// TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted
-// this works well.
-//
-// TODO(ajwong): Make this check for Release() as well.
-// See http://crbug.com/82038.
-template <typename T>
-class SupportsAddRefAndRelease {
-  typedef char Yes[1];
-  typedef char No[2];
-
-  struct BaseMixin {
-    void AddRef();
-  };
-
-// MSVC warns when you try to use Base if T has a private destructor, the
-// common pattern for refcounted types. It does this even though no attempt to
-// instantiate Base is made.  We disable the warning for this definition.
-#if defined(OS_WIN)
-#pragma warning(push)
-#pragma warning(disable : 4624)
-#endif
-  struct Base : public T, public BaseMixin {};
-#if defined(OS_WIN)
-#pragma warning(pop)
-#endif
-
-  template <void (BaseMixin::*)(void)>
-  struct Helper {};
-
-  template <typename C>
-  static No& Check(Helper<&C::AddRef>*);
-
-  template <typename>
-  static Yes& Check(...);
-
- public:
-  static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);
-};
-
-// Helpers to assert that arguments of a recounted type are bound with a
-// scoped_refptr.
-template <bool IsClasstype, typename T>
-struct UnsafeBindtoRefCountedArgHelper : false_type {};
-
-template <typename T>
-struct UnsafeBindtoRefCountedArgHelper<true, T>
-    : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {};
-
-template <typename T>
-struct UnsafeBindtoRefCountedArg : false_type {};
-
-template <typename T>
-struct UnsafeBindtoRefCountedArg<T*>
-    : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {};
-
-template <typename T>
-class HasIsMethodTag {
-  typedef char Yes[1];
-  typedef char No[2];
-
-  template <typename U>
-  static Yes& Check(typename U::IsMethod*);
-
-  template <typename U>
-  static No& Check(...);
-
- public:
-  static const bool value = sizeof(Check<T>(0)) == sizeof(Yes);
-};
-
-template <typename T>
-class UnretainedWrapper {
- public:
-  explicit UnretainedWrapper(T* o) : ptr_(o) {}
-  T* get() const { return ptr_; }
-
- private:
-  T* ptr_;
-};
-
-template <typename T>
-class ConstRefWrapper {
- public:
-  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
-  const T& get() const { return *ptr_; }
-
- private:
-  const T* ptr_;
-};
-
-template <typename T>
-struct IgnoreResultHelper {
-  explicit IgnoreResultHelper(T functor) : functor_(functor) {}
-
-  T functor_;
-};
-
-template <typename T>
-struct IgnoreResultHelper<Callback<T>> {
-  explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
-
-  const Callback<T>& functor_;
-};
-
-// An alternate implementation is to avoid the destructive copy, and instead
-// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
-// a class that is essentially a scoped_ptr<>.
-//
-// The current implementation has the benefit though of leaving ParamTraits<>
-// fully in callback_internal.h as well as avoiding type conversions during
-// storage.
-template <typename T>
-class OwnedWrapper {
- public:
-  explicit OwnedWrapper(T* o) : ptr_(o) {}
-  ~OwnedWrapper() { delete ptr_; }
-  T* get() const { return ptr_; }
-  OwnedWrapper(const OwnedWrapper& other) {
-    ptr_ = other.ptr_;
-    other.ptr_ = NULL;
-  }
-
- private:
-  mutable T* ptr_;
-};
-
-// PassedWrapper is a copyable adapter for a scoper that ignores const.
-//
-// It is needed to get around the fact that Bind() takes a const reference to
-// all its arguments.  Because Bind() takes a const reference to avoid
-// unnecessary copies, it is incompatible with movable-but-not-copyable
-// types; doing a destructive "move" of the type into Bind() would violate
-// the const correctness.
-//
-// This conundrum cannot be solved without either C++11 rvalue references or
-// a O(2^n) blowup of Bind() templates to handle each combination of regular
-// types and movable-but-not-copyable types.  Thus we introduce a wrapper type
-// that is copyable to transmit the correct type information down into
-// BindState<>. Ignoring const in this type makes sense because it is only
-// created when we are explicitly trying to do a destructive move.
-//
-// Two notes:
-//  1) PassedWrapper supports any type that has a "Pass()" function.
-//     This is intentional. The whitelisting of which specific types we
-//     support is maintained by CallbackParamTraits<>.
-//  2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
-//     scoper to a Callback and allow the Callback to execute once.
-template <typename T>
-class PassedWrapper {
- public:
-  explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
-  PassedWrapper(const PassedWrapper& other)
-      : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {}
-  T Pass() const {
-    CHECK(is_valid_);
-    is_valid_ = false;
-    return scoper_.Pass();
-  }
-
- private:
-  mutable bool is_valid_;
-  mutable T scoper_;
-};
-
-// Unwrap the stored parameters for the wrappers above.
-template <typename T>
-struct UnwrapTraits {
-  typedef const T& ForwardType;
-  static ForwardType Unwrap(const T& o) { return o; }
-};
-
-template <typename T>
-struct UnwrapTraits<UnretainedWrapper<T>> {
-  typedef T* ForwardType;
-  static ForwardType Unwrap(UnretainedWrapper<T> unretained) {
-    return unretained.get();
-  }
-};
-
-template <typename T>
-struct UnwrapTraits<ConstRefWrapper<T>> {
-  typedef const T& ForwardType;
-  static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {
-    return const_ref.get();
-  }
-};
-
-template <typename T>
-struct UnwrapTraits<scoped_refptr<T>> {
-  typedef T* ForwardType;
-  static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct UnwrapTraits<WeakPtr<T>> {
-  typedef const WeakPtr<T>& ForwardType;
-  static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
-};
-
-template <typename T>
-struct UnwrapTraits<OwnedWrapper<T>> {
-  typedef T* ForwardType;
-  static ForwardType Unwrap(const OwnedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct UnwrapTraits<PassedWrapper<T>> {
-  typedef T ForwardType;
-  static T Unwrap(PassedWrapper<T>& o) { return o.Pass(); }
-};
-
-// Utility for handling different refcounting semantics in the Bind()
-// function.
-template <bool is_method, typename T>
-struct MaybeRefcount;
-
-template <typename T>
-struct MaybeRefcount<false, T> {
-  static void AddRef(const T&) {}
-  static void Release(const T&) {}
-};
-
-template <typename T, size_t n>
-struct MaybeRefcount<false, T[n]> {
-  static void AddRef(const T*) {}
-  static void Release(const T*) {}
-};
-
-template <typename T>
-struct MaybeRefcount<true, T> {
-  static void AddRef(const T&) {}
-  static void Release(const T&) {}
-};
-
-template <typename T>
-struct MaybeRefcount<true, T*> {
-  static void AddRef(T* o) { o->AddRef(); }
-  static void Release(T* o) { o->Release(); }
-};
-
-// No need to additionally AddRef() and Release() since we are storing a
-// scoped_refptr<> inside the storage object already.
-template <typename T>
-struct MaybeRefcount<true, scoped_refptr<T>> {
-  static void AddRef(const scoped_refptr<T>& o) {}
-  static void Release(const scoped_refptr<T>& o) {}
-};
-
-template <typename T>
-struct MaybeRefcount<true, const T*> {
-  static void AddRef(const T* o) { o->AddRef(); }
-  static void Release(const T* o) { o->Release(); }
-};
-
-// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
-// method.  It is used internally by Bind() to select the correct
-// InvokeHelper that will no-op itself in the event the WeakPtr<> for
-// the target object is invalidated.
-//
-// P1 should be the type of the object that will be received of the method.
-template <bool IsMethod, typename P1>
-struct IsWeakMethod : public false_type {};
-
-template <typename T>
-struct IsWeakMethod<true, WeakPtr<T>> : public true_type {};
-
-template <typename T>
-struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T>>> : public true_type {};
-
-}  // namespace cef_internal
-
-template <typename T>
-static inline cef_internal::UnretainedWrapper<T> Unretained(T* o) {
-  return cef_internal::UnretainedWrapper<T>(o);
-}
-
-template <typename T>
-static inline cef_internal::ConstRefWrapper<T> ConstRef(const T& o) {
-  return cef_internal::ConstRefWrapper<T>(o);
-}
-
-template <typename T>
-static inline cef_internal::OwnedWrapper<T> Owned(T* o) {
-  return cef_internal::OwnedWrapper<T>(o);
-}
-
-// We offer 2 syntaxes for calling Passed().  The first takes a temporary and
-// is best suited for use with the return value of a function. The second
-// takes a pointer to the scoper and is just syntactic sugar to avoid having
-// to write Passed(scoper.Pass()).
-template <typename T>
-static inline cef_internal::PassedWrapper<T> Passed(T scoper) {
-  return cef_internal::PassedWrapper<T>(scoper.Pass());
-}
-template <typename T>
-static inline cef_internal::PassedWrapper<T> Passed(T* scoper) {
-  return cef_internal::PassedWrapper<T>(scoper->Pass());
-}
-
-template <typename T>
-static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
-  return cef_internal::IgnoreResultHelper<T>(data);
-}
-
-template <typename T>
-static inline cef_internal::IgnoreResultHelper<Callback<T>> IgnoreResult(
-    const Callback<T>& data) {
-  return cef_internal::IgnoreResultHelper<Callback<T>>(data);
-}
-
-void DoNothing();
-
-template <typename T>
-void DeletePointer(T* obj) {
-  delete obj;
-}
-
-}  // namespace base
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_BIND_HELPERS_H_

include/base/cef_build.h

@@ -27,61 +27,128 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// This file adds defines about the platform we're currently building on.
+//
+//  Operating System:
+//    OS_AIX / OS_ANDROID / OS_ASMJS / OS_FREEBSD / OS_FUCHSIA / OS_IOS /
+//    OS_LINUX / OS_MAC / OS_NACL (SFI or NONSFI) / OS_NETBSD / OS_OPENBSD /
+//    OS_QNX / OS_SOLARIS / OS_WIN
+//  Operating System family:
+//    OS_APPLE: IOS or MAC
+//    OS_BSD: FREEBSD or NETBSD or OPENBSD
+//    OS_POSIX: AIX or ANDROID or ASMJS or CHROMEOS or FREEBSD or IOS or LINUX
+//              or MAC or NACL or NETBSD or OPENBSD or QNX or SOLARIS
+//
+//  /!\ Note: OS_CHROMEOS is set by the build system, not this file
+//
+//  Compiler:
+//    COMPILER_MSVC / COMPILER_GCC
+//
+//  Processor:
+//    ARCH_CPU_ARM64 / ARCH_CPU_ARMEL / ARCH_CPU_MIPS / ARCH_CPU_MIPS64 /
+//    ARCH_CPU_MIPS64EL / ARCH_CPU_MIPSEL / ARCH_CPU_PPC64 / ARCH_CPU_S390 /
+//    ARCH_CPU_S390X / ARCH_CPU_X86 / ARCH_CPU_X86_64
+//  Processor family:
+//    ARCH_CPU_ARM_FAMILY: ARMEL or ARM64
+//    ARCH_CPU_MIPS_FAMILY: MIPS64EL or MIPSEL or MIPS64 or MIPS
+//    ARCH_CPU_PPC64_FAMILY: PPC64
+//    ARCH_CPU_S390_FAMILY: S390 or S390X
+//    ARCH_CPU_X86_FAMILY: X86 or X86_64
+//  Processor features:
+//    ARCH_CPU_31_BITS / ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
+//    ARCH_CPU_BIG_ENDIAN / ARCH_CPU_LITTLE_ENDIAN
+
 #ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
 #define CEF_INCLUDE_BASE_CEF_BUILD_H_
 #pragma once
 
 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
-#include "base/compiler_specific.h"
+#include "build/build_config.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.
 
-#if defined(_WIN32)
+// A set of macros to use for platform detection.
-#ifndef OS_WIN
+#if defined(ANDROID)
-#define OS_WIN 1
+#define OS_ANDROID 1
-#endif
 #elif defined(__APPLE__)
-// New platform defines after https://crbug.com/1105907.
+// Only include TargetConditionals after testing ANDROID as some Android builds
-#ifndef OS_MAC
+// on the Mac have this header available and it's not needed unless the target
+// is really an Apple platform.
+#include <TargetConditionals.h>
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#define OS_IOS 1
+#else
 #define OS_MAC 1
+// For backwards compatibility.
+#define OS_MACOSX 1
+#endif  // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#elif defined(__linux__)
+#if !defined(OS_CHROMEOS)
+// Do not define OS_LINUX on Chrome OS build.
+// The OS_CHROMEOS macro is defined in GN.
+#define OS_LINUX 1
+#endif  // !defined(OS_CHROMEOS)
+// Include a system header to pull in features.h for glibc/uclibc macros.
+#include <unistd.h>
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+// We really are using glibc, not uClibc pretending to be glibc.
+#define LIBC_GLIBC 1
 #endif
-#ifndef OS_APPLE
+#elif defined(_WIN32)
+#define OS_WIN 1
+#elif defined(__Fuchsia__)
+#define OS_FUCHSIA 1
+#elif defined(__FreeBSD__)
+#define OS_FREEBSD 1
+#elif defined(__NetBSD__)
+#define OS_NETBSD 1
+#elif defined(__OpenBSD__)
+#define OS_OPENBSD 1
+#elif defined(__sun)
+#define OS_SOLARIS 1
+#elif defined(__QNXNTO__)
+#define OS_QNX 1
+#elif defined(_AIX)
+#define OS_AIX 1
+#elif defined(__asmjs__) || defined(__wasm__)
+#define OS_ASMJS 1
+#else
+#error Please add support for your platform in include/base/cef_build.h
+#endif
+// NOTE: Adding a new port? Please follow
+// https://chromium.googlesource.com/chromium/src/+/master/docs/new_port_policy.md
+
+#if defined(OS_MAC) || defined(OS_IOS)
 #define OS_APPLE 1
 #endif
-// Old platform defines retained for backwards compatibility.
+
-#ifndef OS_MACOSX
+// For access to standard BSD features, use OS_BSD instead of a
-#define OS_MACOSX 1
+// more specific macro.
-#endif
+#if defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD)
-#elif defined(__linux__)
+#define OS_BSD 1
-#ifndef OS_LINUX
-#define OS_LINUX 1
-#endif
-#else
-#error Please add support for your platform in cef_build.h
 #endif
 
 // For access to standard POSIXish features, use OS_POSIX instead of a
 // more specific macro.
-#if defined(OS_MAC) || defined(OS_LINUX)
+#if defined(OS_AIX) || defined(OS_ANDROID) || defined(OS_ASMJS) ||  \
-#ifndef OS_POSIX
+    defined(OS_FREEBSD) || defined(OS_IOS) || defined(OS_LINUX) ||  \
+    defined(OS_CHROMEOS) || defined(OS_MAC) || defined(OS_NACL) ||  \
+    defined(OS_NETBSD) || defined(OS_OPENBSD) || defined(OS_QNX) || \
+    defined(OS_SOLARIS)
 #define OS_POSIX 1
 #endif
-#endif
 
-// Compiler detection.
+// Compiler detection. Note: clang masquerades as GCC on POSIX and as MSVC on
+// Windows.
 #if defined(__GNUC__)
-#ifndef COMPILER_GCC
 #define COMPILER_GCC 1
-#endif
 #elif defined(_MSC_VER)
-#ifndef COMPILER_MSVC
 #define COMPILER_MSVC 1
-#endif
 #else
-#error Please add support for your compiler in cef_build.h
+#error Please add support for your compiler in build/build_config.h
 #endif
 
 // Processor architecture detection.  For more info on what's defined, see:
@@ -98,6 +165,26 @@
 #define ARCH_CPU_X86 1
 #define ARCH_CPU_32_BITS 1
 #define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__s390x__)
+#define ARCH_CPU_S390_FAMILY 1
+#define ARCH_CPU_S390X 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif defined(__s390__)
+#define ARCH_CPU_S390_FAMILY 1
+#define ARCH_CPU_S390 1
+#define ARCH_CPU_31_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif (defined(__PPC64__) || defined(__PPC__)) && defined(__BIG_ENDIAN__)
+#define ARCH_CPU_PPC64_FAMILY 1
+#define ARCH_CPU_PPC64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif defined(__PPC64__)
+#define ARCH_CPU_PPC64_FAMILY 1
+#define ARCH_CPU_PPC64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
 #elif defined(__ARMEL__)
 #define ARCH_CPU_ARM_FAMILY 1
 #define ARCH_CPU_ARMEL 1
@@ -108,21 +195,42 @@
 #define ARCH_CPU_ARM64 1
 #define ARCH_CPU_64_BITS 1
 #define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__pnacl__)
+#elif defined(__pnacl__) || defined(__asmjs__) || defined(__wasm__)
 #define ARCH_CPU_32_BITS 1
 #define ARCH_CPU_LITTLE_ENDIAN 1
 #elif defined(__MIPSEL__)
+#if defined(__LP64__)
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS64EL 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#else
 #define ARCH_CPU_MIPS_FAMILY 1
 #define ARCH_CPU_MIPSEL 1
 #define ARCH_CPU_32_BITS 1
 #define ARCH_CPU_LITTLE_ENDIAN 1
+#endif
+#elif defined(__MIPSEB__)
+#if defined(__LP64__)
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
 #else
-#error Please add support for your architecture in cef_build.h
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#endif
+#else
+#error Please add support for your architecture in include/base/cef_build.h
 #endif
 
 // Type detection for wchar_t.
 #if defined(OS_WIN)
 #define WCHAR_T_IS_UTF16
+#elif defined(OS_FUCHSIA)
+#define WCHAR_T_IS_UTF32
 #elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
     (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
 #define WCHAR_T_IS_UTF32
@@ -134,82 +242,18 @@
 // short wchar works for them.
 #define WCHAR_T_IS_UTF16
 #else
-#error Please add support for your compiler in cef_build.h
+#error Please add support for your compiler in include/base/cef_build.h
 #endif
 
-// Annotate a function indicating the caller must examine the return value.
+#if defined(OS_ANDROID)
-// Use like:
+// The compiler thinks std::string::const_iterator and "const char*" are
-//   int foo() WARN_UNUSED_RESULT;
+// equivalent types.
-// To explicitly ignore a result, see |ignore_result()| in <base/macros.h>.
+#define STD_STRING_ITERATOR_IS_CHAR_POINTER
-#ifndef WARN_UNUSED_RESULT
+// The compiler thinks std::u16string::const_iterator and "char16*" are
-#if defined(COMPILER_GCC)
+// equivalent types.
-#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#define BASE_STRING16_ITERATOR_IS_CHAR16_POINTER
-#else
-#define WARN_UNUSED_RESULT
-#endif
-#endif  // WARN_UNUSED_RESULT
-
-// Annotate a typedef or function indicating it's ok if it's not used.
-// Use like:
-//   typedef Foo Bar ALLOW_UNUSED_TYPE;
-#ifndef ALLOW_UNUSED_TYPE
-#if defined(COMPILER_GCC)
-#define ALLOW_UNUSED_TYPE __attribute__((unused))
-#else
-#define ALLOW_UNUSED_TYPE
-#endif
-#endif  // ALLOW_UNUSED_TYPE
-
-// Annotate a variable indicating it's ok if the variable is not used.
-// (Typically used to silence a compiler warning when the assignment
-// is important for some other reason.)
-// Use like:
-//   int x = ...;
-//   ALLOW_UNUSED_LOCAL(x);
-#ifndef ALLOW_UNUSED_LOCAL
-#define ALLOW_UNUSED_LOCAL(x) false ? (void)x : (void)0
-#endif
-
-// Sanitizers annotations.
-#if defined(__has_attribute)
-#if __has_attribute(no_sanitize)
-#define NO_SANITIZE(what) __attribute__((no_sanitize(what)))
-#endif
-#endif
-#if !defined(NO_SANITIZE)
-#define NO_SANITIZE(what)
 #endif
 
 #endif  // !USING_CHROMIUM_INCLUDES
 
-// Annotate a virtual method indicating it must be overriding a virtual method
-// in the parent class.
-// Use like:
-//   void foo() OVERRIDE;
-// NOTE: This define should only be used in classes exposed to the client since
-// C++11 support may not be enabled in client applications. CEF internal classes
-// should use the `override` keyword directly.
-#ifndef OVERRIDE
-#if defined(__clang__)
-#define OVERRIDE override
-#elif defined(COMPILER_MSVC) && _MSC_VER >= 1600
-// Visual Studio 2010 and later support override.
-#define OVERRIDE override
-#elif defined(COMPILER_GCC) && __cplusplus >= 201103 && \
-    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40700
-// GCC 4.7 supports explicit virtual overrides when C++11 support is enabled.
-#define OVERRIDE override
-#else
-#define OVERRIDE
-#endif
-#endif  // OVERRIDE
-
-// Check for C++11 template alias support which was added in VS2013 and GCC4.7.
-// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
-#if __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER >= 1800) || \
-    (defined(__GNUC__) &&                                               \
-     (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ >= 40700))
-#define HAS_CPP11_TEMPLATE_ALIAS_SUPPORT
-#endif
-
 #endif  // CEF_INCLUDE_BASE_CEF_BUILD_H_

include/base/cef_callback.h

@@ -28,16 +28,46 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// Overview:
+// A callback is similar in concept to a function pointer: it wraps a runnable
+// object such as a function, method, lambda, or even another callback, allowing
+// the runnable object to be invoked later via the callback object.
+//
+// Unlike function pointers, callbacks are created with base::BindOnce() or
+// base::BindRepeating() and support partial function application.
+//
+// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may
+// be Run() any number of times. |is_null()| is guaranteed to return true for a
+// moved-from callback.
+//
+//   // The lambda takes two arguments, but the first argument |x| is bound at
+//   // callback creation.
+//   base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
+//     return x + y;
+//   }, 1);
+//   // Run() only needs the remaining unbound argument |y|.
+//   printf("1 + 2 = %d\n", std::move(cb).Run(2));  // Prints 3
+//   printf("cb is null? %s\n",
+//          cb.is_null() ? "true" : "false");  // Prints true
+//   std::move(cb).Run(2);  // Crashes since |cb| has already run.
+//
+// Callbacks also support cancellation. A common use is binding the receiver
+// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
+// will be a no-op. Note that |IsCancelled()| and |is_null()| are distinct:
+// simply cancelling a callback will not also make it null.
+//
+// See https://chromium.googlesource.com/chromium/src/+/HEAD/docs/callback.md
+// for the full documentation.
+
 #ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_H_
 #define CEF_INCLUDE_BASE_CEF_CALLBACK_H_
 #pragma once
 
-#if defined(BASE_CALLBACK_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/callback.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -45,755 +75,175 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
+#include <stddef.h>
+
+#include "include/base/cef_bind.h"
 #include "include/base/cef_callback_forward.h"
-#include "include/base/cef_template_util.h"
+#include "include/base/cef_logging.h"
 #include "include/base/internal/cef_callback_internal.h"
 
-// NOTE: Header files that do not require the full definition of Callback or
-// Closure should #include "base/cef_callback_forward.h" instead of this file.
-
-// -----------------------------------------------------------------------------
-// Introduction
-// -----------------------------------------------------------------------------
-//
-// The templated Callback class is a generalized function object. Together
-// with the Bind() function in bind.h, they provide a type-safe method for
-// performing partial application of functions.
-//
-// Partial application (or "currying") is the process of binding a subset of
-// a function's arguments to produce another function that takes fewer
-// arguments. This can be used to pass around a unit of delayed execution,
-// much like lexical closures are used in other languages. For example, it
-// is used in Chromium code to schedule tasks on different MessageLoops.
-//
-// A callback with no unbound input parameters (base::Callback<void(void)>)
-// is called a base::Closure. Note that this is NOT the same as what other
-// languages refer to as a closure -- it does not retain a reference to its
-// enclosing environment.
-//
-// MEMORY MANAGEMENT AND PASSING
-//
-// The Callback objects themselves should be passed by const-reference, and
-// stored by copy. They internally store their state via a refcounted class
-// and thus do not need to be deleted.
-//
-// The reason to pass via a const-reference is to avoid unnecessary
-// AddRef/Release pairs to the internal state.
-//
-//
-// -----------------------------------------------------------------------------
-// Quick reference for basic stuff
-// -----------------------------------------------------------------------------
-//
-// BINDING A BARE FUNCTION
-//
-//   int Return5() { return 5; }
-//   base::Callback<int(void)> func_cb = base::Bind(&Return5);
-//   LOG(INFO) << func_cb.Run();  // Prints 5.
-//
-// BINDING A CLASS METHOD
-//
-//   The first argument to bind is the member function to call, the second is
-//   the object on which to call it.
-//
-//   class Ref : public base::RefCountedThreadSafe<Ref> {
-//    public:
-//     int Foo() { return 3; }
-//     void PrintBye() { LOG(INFO) << "bye."; }
-//   };
-//   scoped_refptr<Ref> ref = new Ref();
-//   base::Callback<void(void)> ref_cb = base::Bind(&Ref::Foo, ref);
-//   LOG(INFO) << ref_cb.Run();  // Prints out 3.
-//
-//   By default the object must support RefCounted or you will get a compiler
-//   error. If you're passing between threads, be sure it's
-//   RefCountedThreadSafe! See "Advanced binding of member functions" below if
-//   you don't want to use reference counting.
-//
-// RUNNING A CALLBACK
-//
-//   Callbacks can be run with their "Run" method, which has the same
-//   signature as the template argument to the callback.
-//
-//   void DoSomething(const base::Callback<void(int, std::string)>& callback) {
-//     callback.Run(5, "hello");
-//   }
-//
-//   Callbacks can be run more than once (they don't get deleted or marked when
-//   run). However, this precludes using base::Passed (see below).
-//
-//   void DoSomething(const base::Callback<double(double)>& callback) {
-//     double myresult = callback.Run(3.14159);
-//     myresult += callback.Run(2.71828);
-//   }
-//
-// PASSING UNBOUND INPUT PARAMETERS
-//
-//   Unbound parameters are specified at the time a callback is Run(). They are
-//   specified in the Callback template type:
-//
-//   void MyFunc(int i, const std::string& str) {}
-//   base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc);
-//   cb.Run(23, "hello, world");
-//
-// PASSING BOUND INPUT PARAMETERS
-//
-//   Bound parameters are specified when you create thee callback as arguments
-//   to Bind(). They will be passed to the function and the Run()ner of the
-//   callback doesn't see those values or even know that the function it's
-//   calling.
-//
-//   void MyFunc(int i, const std::string& str) {}
-//   base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world");
-//   cb.Run();
-//
-//   A callback with no unbound input parameters (base::Callback<void(void)>)
-//   is called a base::Closure. So we could have also written:
-//
-//   base::Closure cb = base::Bind(&MyFunc, 23, "hello world");
-//
-//   When calling member functions, bound parameters just go after the object
-//   pointer.
-//
-//   base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world");
-//
-// PARTIAL BINDING OF PARAMETERS
-//
-//   You can specify some parameters when you create the callback, and specify
-//   the rest when you execute the callback.
-//
-//   void MyFunc(int i, const std::string& str) {}
-//   base::Callback<void(const std::string&)> cb = base::Bind(&MyFunc, 23);
-//   cb.Run("hello world");
-//
-//   When calling a function bound parameters are first, followed by unbound
-//   parameters.
-//
-//
-// -----------------------------------------------------------------------------
-// Quick reference for advanced binding
-// -----------------------------------------------------------------------------
-//
-// BINDING A CLASS METHOD WITH WEAK POINTERS
-//
-//   base::Bind(&MyClass::Foo, GetWeakPtr());
-//
-//   The callback will not be run if the object has already been destroyed.
-//   DANGER: weak pointers are not threadsafe, so don't use this
-//   when passing between threads!
-//
-// BINDING A CLASS METHOD WITH MANUAL LIFETIME MANAGEMENT
-//
-//   base::Bind(&MyClass::Foo, base::Unretained(this));
-//
-//   This disables all lifetime management on the object. You're responsible
-//   for making sure the object is alive at the time of the call. You break it,
-//   you own it!
-//
-// BINDING A CLASS METHOD AND HAVING THE CALLBACK OWN THE CLASS
-//
-//   MyClass* myclass = new MyClass;
-//   base::Bind(&MyClass::Foo, base::Owned(myclass));
-//
-//   The object will be deleted when the callback is destroyed, even if it's
-//   not run (like if you post a task during shutdown). Potentially useful for
-//   "fire and forget" cases.
-//
-// IGNORING RETURN VALUES
-//
-//   Sometimes you want to call a function that returns a value in a callback
-//   that doesn't expect a return value.
-//
-//   int DoSomething(int arg) { cout << arg << endl; }
-//   base::Callback<void<int>) cb =
-//       base::Bind(base::IgnoreResult(&DoSomething));
-//
-//
-// -----------------------------------------------------------------------------
-// Quick reference for binding parameters to Bind()
-// -----------------------------------------------------------------------------
-//
-// Bound parameters are specified as arguments to Bind() and are passed to the
-// function. A callback with no parameters or no unbound parameters is called a
-// Closure (base::Callback<void(void)> and base::Closure are the same thing).
-//
-// PASSING PARAMETERS OWNED BY THE CALLBACK
-//
-//   void Foo(int* arg) { cout << *arg << endl; }
-//   int* pn = new int(1);
-//   base::Closure foo_callback = base::Bind(&foo, base::Owned(pn));
-//
-//   The parameter will be deleted when the callback is destroyed, even if it's
-//   not run (like if you post a task during shutdown).
-//
-// PASSING PARAMETERS AS A scoped_ptr
-//
-//   void TakesOwnership(scoped_ptr<Foo> arg) {}
-//   scoped_ptr<Foo> f(new Foo);
-//   // f becomes null during the following call.
-//   base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f));
-//
-//   Ownership of the parameter will be with the callback until the it is run,
-//   when ownership is passed to the callback function. This means the callback
-//   can only be run once. If the callback is never run, it will delete the
-//   object when it's destroyed.
-//
-// PASSING PARAMETERS AS A scoped_refptr
-//
-//   void TakesOneRef(scoped_refptr<Foo> arg) {}
-//   scoped_refptr<Foo> f(new Foo)
-//   base::Closure cb = base::Bind(&TakesOneRef, f);
-//
-//   This should "just work." The closure will take a reference as long as it
-//   is alive, and another reference will be taken for the called function.
-//
-// PASSING PARAMETERS BY REFERENCE
-//
-//   Const references are *copied* unless ConstRef is used. Example:
-//
-//   void foo(const int& arg) { printf("%d %p\n", arg, &arg); }
-//   int n = 1;
-//   base::Closure has_copy = base::Bind(&foo, n);
-//   base::Closure has_ref = base::Bind(&foo, base::ConstRef(n));
-//   n = 2;
-//   foo(n);                        // Prints "2 0xaaaaaaaaaaaa"
-//   has_copy.Run();                // Prints "1 0xbbbbbbbbbbbb"
-//   has_ref.Run();                 // Prints "2 0xaaaaaaaaaaaa"
-//
-//   Normally parameters are copied in the closure. DANGER: ConstRef stores a
-//   const reference instead, referencing the original parameter. This means
-//   that you must ensure the object outlives the callback!
-//
-//
-// -----------------------------------------------------------------------------
-// Implementation notes
-// -----------------------------------------------------------------------------
-//
-// WHERE IS THIS DESIGN FROM:
-//
-// The design Callback and Bind is heavily influenced by C++'s
-// tr1::function/tr1::bind, and by the "Google Callback" system used inside
-// Google.
-//
-//
-// HOW THE IMPLEMENTATION WORKS:
-//
-// There are three main components to the system:
-//   1) The Callback classes.
-//   2) The Bind() functions.
-//   3) The arguments wrappers (e.g., Unretained() and ConstRef()).
-//
-// The Callback classes represent a generic function pointer. Internally,
-// it stores a refcounted piece of state that represents the target function
-// and all its bound parameters.  Each Callback specialization has a templated
-// constructor that takes an BindState<>*.  In the context of the constructor,
-// the static type of this BindState<> pointer uniquely identifies the
-// function it is representing, all its bound parameters, and a Run() method
-// that is capable of invoking the target.
-//
-// Callback's constructor takes the BindState<>* that has the full static type
-// and erases the target function type as well as the types of the bound
-// parameters.  It does this by storing a pointer to the specific Run()
-// function, and upcasting the state of BindState<>* to a
-// BindStateBase*. This is safe as long as this BindStateBase pointer
-// is only used with the stored Run() pointer.
-//
-// To BindState<> objects are created inside the Bind() functions.
-// These functions, along with a set of internal templates, are responsible for
-//
-//  - Unwrapping the function signature into return type, and parameters
-//  - Determining the number of parameters that are bound
-//  - Creating the BindState storing the bound parameters
-//  - Performing compile-time asserts to avoid error-prone behavior
-//  - Returning an Callback<> with an arity matching the number of unbound
-//    parameters and that knows the correct refcounting semantics for the
-//    target object if we are binding a method.
-//
-// The Bind functions do the above using type-inference, and template
-// specializations.
-//
-// By default Bind() will store copies of all bound parameters, and attempt
-// to refcount a target object if the function being bound is a class method.
-// These copies are created even if the function takes parameters as const
-// references. (Binding to non-const references is forbidden, see bind.h.)
-//
-// To change this behavior, we introduce a set of argument wrappers
-// (e.g., Unretained(), and ConstRef()).  These are simple container templates
-// that are passed by value, and wrap a pointer to argument.  See the
-// file-level comment in base/bind_helpers.h for more info.
-//
-// These types are passed to the Unwrap() functions, and the MaybeRefcount()
-// functions respectively to modify the behavior of Bind().  The Unwrap()
-// and MaybeRefcount() functions change behavior by doing partial
-// specialization based on whether or not a parameter is a wrapper type.
-//
-// ConstRef() is similar to tr1::cref.  Unretained() is specific to Chromium.
-//
-//
-// WHY NOT TR1 FUNCTION/BIND?
-//
-// Direct use of tr1::function and tr1::bind was considered, but ultimately
-// rejected because of the number of copy constructors invocations involved
-// in the binding of arguments during construction, and the forwarding of
-// arguments during invocation.  These copies will no longer be an issue in
-// C++0x because C++0x will support rvalue reference allowing for the compiler
-// to avoid these copies.  However, waiting for C++0x is not an option.
-//
-// Measured with valgrind on gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5), the
-// tr1::bind call itself will invoke a non-trivial copy constructor three times
-// for each bound parameter.  Also, each when passing a tr1::function, each
-// bound argument will be copied again.
-//
-// In addition to the copies taken at binding and invocation, copying a
-// tr1::function causes a copy to be made of all the bound parameters and
-// state.
-//
-// Furthermore, in Chromium, it is desirable for the Callback to take a
-// reference on a target object when representing a class method call.  This
-// is not supported by tr1.
-//
-// Lastly, tr1::function and tr1::bind has a more general and flexible API.
-// This includes things like argument reordering by use of
-// tr1::bind::placeholder, support for non-const reference parameters, and some
-// limited amount of subtyping of the tr1::function object (e.g.,
-// tr1::function<int(int)> is convertible to tr1::function<void(int)>).
-//
-// These are not features that are required in Chromium. Some of them, such as
-// allowing for reference parameters, and subtyping of functions, may actually
-// become a source of errors. Removing support for these features actually
-// allows for a simpler implementation, and a terser Currying API.
-//
-//
-// WHY NOT GOOGLE CALLBACKS?
-//
-// The Google callback system also does not support refcounting.  Furthermore,
-// its implementation has a number of strange edge cases with respect to type
-// conversion of its arguments.  In particular, the argument's constness must
-// at times match exactly the function signature, or the type-inference might
-// break.  Given the above, writing a custom solution was easier.
-//
-//
-// MISSING FUNCTIONALITY
-//  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
-//  - Binding arrays to functions that take a non-const pointer.
-//    Example:
-//      void Foo(const char* ptr);
-//      void Bar(char* ptr);
-//      Bind(&Foo, "test");
-//      Bind(&Bar, "test");  // This fails because ptr is not const.
-
 namespace base {
 
-// First, we forward declare the Callback class template. This informs the
+template <typename R, typename... Args>
-// compiler that the template only has 1 type parameter which is the function
+class OnceCallback<R(Args...)> : public internal::CallbackBase {
-// signature that the Callback is representing.
-//
-// After this, create template specializations for 0-7 parameters. Note that
-// even though the template typelist grows, the specialization still
-// only has one type: the function signature.
-//
-// If you are thinking of forward declaring Callback in your own header file,
-// please include "base/callback_forward.h" instead.
-template <typename Sig>
-class Callback;
-
-namespace cef_internal {
-template <typename Runnable, typename RunType, typename BoundArgsType>
-struct BindState;
-}  // namespace cef_internal
-
-template <typename R>
-class Callback<R(void)> : public cef_internal::CallbackBase {
  public:
-  typedef R(RunType)();
+  using ResultType = R;
+  using RunType = R(Args...);
+  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
+                                  internal::PassingType<Args>...);
 
-  Callback() : CallbackBase(NULL) {}
+  constexpr OnceCallback() = default;
+  OnceCallback(std::nullptr_t) = delete;
 
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  explicit OnceCallback(internal::BindStateBase* bind_state)
-  // return the exact Callback<> type.  See base/bind.h for details.
+      : internal::CallbackBase(bind_state) {}
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+
-  Callback(
+  OnceCallback(const OnceCallback&) = delete;
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
+  OnceCallback& operator=(const OnceCallback&) = delete;
-      : CallbackBase(bind_state) {
+
-    // Force the assignment to a local variable of PolymorphicInvoke
+  OnceCallback(OnceCallback&&) noexcept = default;
-    // so the compiler will typecheck that the passed in Run() method has
+  OnceCallback& operator=(OnceCallback&&) noexcept = default;
-    // the correct type.
+
-    PolymorphicInvoke invoke_func =
+  OnceCallback(RepeatingCallback<RunType> other)
-        &cef_internal::BindState<Runnable, BindRunType,
+      : internal::CallbackBase(std::move(other)) {}
-                                 BoundArgsType>::InvokerType::Run;
+
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
+  OnceCallback& operator=(RepeatingCallback<RunType> other) {
+    static_cast<internal::CallbackBase&>(*this) = std::move(other);
+    return *this;
   }
 
-  bool Equals(const Callback& other) const {
+  R Run(Args... args) const& {
-    return CallbackBase::Equals(other);
+    static_assert(!sizeof(*this),
+                  "OnceCallback::Run() may only be invoked on a non-const "
+                  "rvalue, i.e. std::move(callback).Run().");
+    NOTREACHED();
   }
 
-  R Run() const {
+  R Run(Args... args) && {
+    // Move the callback instance into a local variable before the invocation,
+    // that ensures the internal state is cleared after the invocation.
+    // It's not safe to touch |this| after the invocation, since running the
+    // bound function may destroy |this|.
+    OnceCallback cb = std::move(*this);
     PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
-
+    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
-    return f(bind_state_.get());
   }
 
- private:
+  // Then() returns a new OnceCallback that receives the same arguments as
-  typedef R (*PolymorphicInvoke)(cef_internal::BindStateBase*);
+  // |this|, and with the return type of |then|. The returned callback will:
+  // 1) Run the functor currently bound to |this| callback.
+  // 2) Run the |then| callback with the result from step 1 as its single
+  //    argument.
+  // 3) Return the value from running the |then| callback.
+  //
+  // Since this method generates a callback that is a replacement for `this`,
+  // `this` will be consumed and reset to a null callback to ensure the
+  // originally-bound functor can be run at most once.
+  template <typename ThenR, typename... ThenArgs>
+  OnceCallback<ThenR(Args...)> Then(OnceCallback<ThenR(ThenArgs...)> then) && {
+    CHECK(then);
+    return BindOnce(
+        internal::ThenHelper<
+            OnceCallback, OnceCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
+        std::move(*this), std::move(then));
+  }
+
+  // This overload is required; even though RepeatingCallback is implicitly
+  // convertible to OnceCallback, that conversion will not used when matching
+  // for template argument deduction.
+  template <typename ThenR, typename... ThenArgs>
+  OnceCallback<ThenR(Args...)> Then(
+      RepeatingCallback<ThenR(ThenArgs...)> then) && {
+    CHECK(then);
+    return BindOnce(
+        internal::ThenHelper<
+            OnceCallback,
+            RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
+        std::move(*this), std::move(then));
+  }
 };
 
-template <typename R, typename A1>
+template <typename R, typename... Args>
-class Callback<R(A1)> : public cef_internal::CallbackBase {
+class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
  public:
-  typedef R(RunType)(A1);
+  using ResultType = R;
+  using RunType = R(Args...);
+  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
+                                  internal::PassingType<Args>...);
 
-  Callback() : CallbackBase(NULL) {}
+  constexpr RepeatingCallback() = default;
+  RepeatingCallback(std::nullptr_t) = delete;
 
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
+  explicit RepeatingCallback(internal::BindStateBase* bind_state)
-  // return the exact Callback<> type.  See base/bind.h for details.
+      : internal::CallbackBaseCopyable(bind_state) {}
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
+
-  Callback(
+  // Copyable and movable.
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
+  RepeatingCallback(const RepeatingCallback&) = default;
-      : CallbackBase(bind_state) {
+  RepeatingCallback& operator=(const RepeatingCallback&) = default;
-    // Force the assignment to a local variable of PolymorphicInvoke
+  RepeatingCallback(RepeatingCallback&&) noexcept = default;
-    // so the compiler will typecheck that the passed in Run() method has
+  RepeatingCallback& operator=(RepeatingCallback&&) noexcept = default;
-    // the correct type.
+
-    PolymorphicInvoke invoke_func =
+  bool operator==(const RepeatingCallback& other) const {
-        &cef_internal::BindState<Runnable, BindRunType,
+    return EqualsInternal(other);
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
   }
 
-  bool Equals(const Callback& other) const {
+  bool operator!=(const RepeatingCallback& other) const {
-    return CallbackBase::Equals(other);
+    return !operator==(other);
   }
 
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) const {
+  R Run(Args... args) const& {
     PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+        reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke());
-
+    return f(this->bind_state_.get(), std::forward<Args>(args)...);
-    return f(bind_state_.get(), cef_internal::CallbackForward(a1));
   }
 
- private:
+  R Run(Args... args) && {
-  typedef R (*PolymorphicInvoke)(
+    // Move the callback instance into a local variable before the invocation,
-      cef_internal::BindStateBase*,
+    // that ensures the internal state is cleared after the invocation.
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType);
+    // It's not safe to touch |this| after the invocation, since running the
-};
+    // bound function may destroy |this|.
-
+    RepeatingCallback cb = std::move(*this);
-template <typename R, typename A1, typename A2>
-class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) const {
     PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
-
+    return f(std::move(cb).bind_state_.get(), std::forward<Args>(args)...);
-    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
-             cef_internal::CallbackForward(a2));
   }
 
- private:
+  // Then() returns a new RepeatingCallback that receives the same arguments as
-  typedef R (*PolymorphicInvoke)(
+  // |this|, and with the return type of |then|. The
-      cef_internal::BindStateBase*,
+  // returned callback will:
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
+  // 1) Run the functor currently bound to |this| callback.
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType);
+  // 2) Run the |then| callback with the result from step 1 as its single
+  //    argument.
+  // 3) Return the value from running the |then| callback.
+  //
+  // If called on an rvalue (e.g. std::move(cb).Then(...)), this method
+  // generates a callback that is a replacement for `this`. Therefore, `this`
+  // will be consumed and reset to a null callback to ensure the
+  // originally-bound functor will be run at most once.
+  template <typename ThenR, typename... ThenArgs>
+  RepeatingCallback<ThenR(Args...)> Then(
+      RepeatingCallback<ThenR(ThenArgs...)> then) const& {
+    CHECK(then);
+    return BindRepeating(
+        internal::ThenHelper<
+            RepeatingCallback,
+            RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
+        *this, std::move(then));
+  }
+
+  template <typename ThenR, typename... ThenArgs>
+  RepeatingCallback<ThenR(Args...)> Then(
+      RepeatingCallback<ThenR(ThenArgs...)> then) && {
+    CHECK(then);
+    return BindRepeating(
+        internal::ThenHelper<
+            RepeatingCallback,
+            RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),
+        std::move(*this), std::move(then));
+  }
 };
 
-template <typename R, typename A1, typename A2, typename A3>
-class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2, A3);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) const {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
-             cef_internal::CallbackForward(a2),
-             cef_internal::CallbackForward(a3));
-  }
-
- private:
-  typedef R (*PolymorphicInvoke)(
-      cef_internal::BindStateBase*,
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A3>::ForwardType);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2, A3, A4);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) const {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(bind_state_.get(), cef_internal::CallbackForward(a1),
-             cef_internal::CallbackForward(a2),
-             cef_internal::CallbackForward(a3),
-             cef_internal::CallbackForward(a4));
-  }
-
- private:
-  typedef R (*PolymorphicInvoke)(
-      cef_internal::BindStateBase*,
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A3>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A4>::ForwardType);
-};
-
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5>
-class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) const {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(
-        bind_state_.get(), cef_internal::CallbackForward(a1),
-        cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
-        cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5));
-  }
-
- private:
-  typedef R (*PolymorphicInvoke)(
-      cef_internal::BindStateBase*,
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A3>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A4>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A5>::ForwardType);
-};
-
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6>
-class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
-        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) const {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(
-        bind_state_.get(), cef_internal::CallbackForward(a1),
-        cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
-        cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
-        cef_internal::CallbackForward(a6));
-  }
-
- private:
-  typedef R (*PolymorphicInvoke)(
-      cef_internal::BindStateBase*,
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A3>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A4>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A5>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A6>::ForwardType);
-};
-
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6,
-          typename A7>
-class Callback<R(A1, A2, A3, A4, A5, A6, A7)>
-    : public cef_internal::CallbackBase {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
-
-  Callback() : CallbackBase(NULL) {}
-
-  // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
-  // return the exact Callback<> type.  See base/bind.h for details.
-  template <typename Runnable, typename BindRunType, typename BoundArgsType>
-  Callback(
-      cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
-      : CallbackBase(bind_state) {
-    // Force the assignment to a local variable of PolymorphicInvoke
-    // so the compiler will typecheck that the passed in Run() method has
-    // the correct type.
-    PolymorphicInvoke invoke_func =
-        &cef_internal::BindState<Runnable, BindRunType,
-                                 BoundArgsType>::InvokerType::Run;
-    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
-  }
-
-  bool Equals(const Callback& other) const {
-    return CallbackBase::Equals(other);
-  }
-
-  R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-        typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-        typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-        typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-        typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
-        typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
-        typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) const {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
-
-    return f(
-        bind_state_.get(), cef_internal::CallbackForward(a1),
-        cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
-        cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
-        cef_internal::CallbackForward(a6), cef_internal::CallbackForward(a7));
-  }
-
- private:
-  typedef R (*PolymorphicInvoke)(
-      cef_internal::BindStateBase*,
-      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A2>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A3>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A4>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A5>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A6>::ForwardType,
-      typename cef_internal::CallbackParamTraits<A7>::ForwardType);
-};
-
-// Syntactic sugar to make Callbacks<void(void)> easier to declare since it
-// will be used in a lot of APIs with delayed execution.
-typedef Callback<void(void)> Closure;
-
 }  // namespace base
 
 #endif  // !USING_CHROMIUM_INCLUDES

include/base/cef_callback_forward.h

@@ -32,12 +32,7 @@
 #define INCLUDE_BASE_CEF_CALLBACK_FORWARD_H_
 #pragma once
 
-#if defined(BASE_CALLBACK_FORWARD_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/callback_forward.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -47,10 +42,17 @@
 
 namespace base {
 
-template <typename Sig>
+template <typename Signature>
-class Callback;
+class OnceCallback;
 
-typedef Callback<void(void)> Closure;
+template <typename Signature>
+class RepeatingCallback;
+
+// Syntactic sugar to make OnceClosure<void()> and RepeatingClosure<void()>
+// easier to declare since they will be used in a lot of APIs with delayed
+// execution.
+using OnceClosure = OnceCallback<void()>;
+using RepeatingClosure = RepeatingCallback<void()>;
 
 }  // namespace base
 

include/base/cef_callback_helpers.h

@@ -0,0 +1,241 @@
+// Copyright (c) 2014 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.
+
+// This defines helpful methods for dealing with Callbacks.  Because Callbacks
+// are implemented using templates, with a class per callback signature, adding
+// methods to Callback<> itself is unattractive (lots of extra code gets
+// generated).  Instead, consider adding methods here.
+
+#ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#define CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/callback_helpers.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <atomic>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "include/base/cef_bind.h"
+#include "include/base/cef_callback.h"
+#include "include/base/cef_compiler_specific.h"
+#include "include/base/cef_logging.h"
+
+namespace base {
+
+namespace internal {
+
+template <typename T>
+struct IsBaseCallbackImpl : std::false_type {};
+
+template <typename R, typename... Args>
+struct IsBaseCallbackImpl<OnceCallback<R(Args...)>> : std::true_type {};
+
+template <typename R, typename... Args>
+struct IsBaseCallbackImpl<RepeatingCallback<R(Args...)>> : std::true_type {};
+
+template <typename T>
+struct IsOnceCallbackImpl : std::false_type {};
+
+template <typename R, typename... Args>
+struct IsOnceCallbackImpl<OnceCallback<R(Args...)>> : std::true_type {};
+
+}  // namespace internal
+
+// IsBaseCallback<T>::value is true when T is any of the Closure or Callback
+// family of types.
+template <typename T>
+using IsBaseCallback = internal::IsBaseCallbackImpl<std::decay_t<T>>;
+
+// IsOnceCallback<T>::value is true when T is a OnceClosure or OnceCallback
+// type.
+template <typename T>
+using IsOnceCallback = internal::IsOnceCallbackImpl<std::decay_t<T>>;
+
+// SFINAE friendly enabler allowing to overload methods for both Repeating and
+// OnceCallbacks.
+//
+// Usage:
+// template <template <typename> class CallbackType,
+//           ... other template args ...,
+//           typename = EnableIfIsBaseCallback<CallbackType>>
+// void DoStuff(CallbackType<...> cb, ...);
+template <template <typename> class CallbackType>
+using EnableIfIsBaseCallback =
+    std::enable_if_t<IsBaseCallback<CallbackType<void()>>::value>;
+
+namespace internal {
+
+template <typename... Args>
+class OnceCallbackHolder final {
+ public:
+  OnceCallbackHolder(OnceCallback<void(Args...)> callback,
+                     bool ignore_extra_runs)
+      : callback_(std::move(callback)), ignore_extra_runs_(ignore_extra_runs) {
+    DCHECK(callback_);
+  }
+  OnceCallbackHolder(const OnceCallbackHolder&) = delete;
+  OnceCallbackHolder& operator=(const OnceCallbackHolder&) = delete;
+
+  void Run(Args... args) {
+    if (has_run_.exchange(true)) {
+      CHECK(ignore_extra_runs_) << "Both OnceCallbacks returned by "
+                                   "base::SplitOnceCallback() were run. "
+                                   "At most one of the pair should be run.";
+      return;
+    }
+    DCHECK(callback_);
+    std::move(callback_).Run(std::forward<Args>(args)...);
+  }
+
+ private:
+  volatile std::atomic_bool has_run_{false};
+  base::OnceCallback<void(Args...)> callback_;
+  const bool ignore_extra_runs_;
+};
+
+}  // namespace internal
+
+// Wraps the given OnceCallback into a RepeatingCallback that relays its
+// invocation to the original OnceCallback on the first invocation. The
+// following invocations are just ignored.
+//
+// Note that this deliberately subverts the Once/Repeating paradigm of Callbacks
+// but helps ease the migration from old-style Callbacks. Avoid if possible; use
+// if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593
+template <typename... Args>
+RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
+    OnceCallback<void(Args...)> callback) {
+  using Helper = internal::OnceCallbackHolder<Args...>;
+  return base::BindRepeating(
+      &Helper::Run, std::make_unique<Helper>(std::move(callback),
+                                             /*ignore_extra_runs=*/true));
+}
+
+// Wraps the given OnceCallback and returns two OnceCallbacks with an identical
+// signature. On first invokation of either returned callbacks, the original
+// callback is invoked. Invoking the remaining callback results in a crash.
+template <typename... Args>
+std::pair<OnceCallback<void(Args...)>, OnceCallback<void(Args...)>>
+SplitOnceCallback(OnceCallback<void(Args...)> callback) {
+  using Helper = internal::OnceCallbackHolder<Args...>;
+  auto wrapped_once = base::BindRepeating(
+      &Helper::Run, std::make_unique<Helper>(std::move(callback),
+                                             /*ignore_extra_runs=*/false));
+  return std::make_pair(wrapped_once, wrapped_once);
+}
+
+// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
+// that the Closure is executed no matter how the current scope exits.
+// If you are looking for "ScopedCallback", "CallbackRunner", or
+// "CallbackScoper" this is the class you want.
+class ScopedClosureRunner {
+ public:
+  ScopedClosureRunner();
+  explicit ScopedClosureRunner(OnceClosure closure);
+  ScopedClosureRunner(ScopedClosureRunner&& other);
+  // Runs the current closure if it's set, then replaces it with the closure
+  // from |other|. This is akin to how unique_ptr frees the contained pointer in
+  // its move assignment operator. If you need to explicitly avoid running any
+  // current closure, use ReplaceClosure().
+  ScopedClosureRunner& operator=(ScopedClosureRunner&& other);
+  ~ScopedClosureRunner();
+
+  explicit operator bool() const { return !!closure_; }
+
+  // Calls the current closure and resets it, so it wont be called again.
+  void RunAndReset();
+
+  // Replaces closure with the new one releasing the old one without calling it.
+  void ReplaceClosure(OnceClosure closure);
+
+  // Releases the Closure without calling.
+  OnceClosure Release() WARN_UNUSED_RESULT;
+
+ private:
+  OnceClosure closure_;
+};
+
+// Creates a null callback.
+class NullCallback {
+ public:
+  template <typename R, typename... Args>
+  operator RepeatingCallback<R(Args...)>() const {
+    return RepeatingCallback<R(Args...)>();
+  }
+  template <typename R, typename... Args>
+  operator OnceCallback<R(Args...)>() const {
+    return OnceCallback<R(Args...)>();
+  }
+};
+
+// Creates a callback that does nothing when called.
+class DoNothing {
+ public:
+  template <typename... Args>
+  operator RepeatingCallback<void(Args...)>() const {
+    return Repeatedly<Args...>();
+  }
+  template <typename... Args>
+  operator OnceCallback<void(Args...)>() const {
+    return Once<Args...>();
+  }
+  // Explicit way of specifying a specific callback type when the compiler can't
+  // deduce it.
+  template <typename... Args>
+  static RepeatingCallback<void(Args...)> Repeatedly() {
+    return BindRepeating([](Args... args) {});
+  }
+  template <typename... Args>
+  static OnceCallback<void(Args...)> Once() {
+    return BindOnce([](Args... args) {});
+  }
+};
+
+// Useful for creating a Closure that will delete a pointer when invoked. Only
+// use this when necessary. In most cases MessageLoop::DeleteSoon() is a better
+// fit.
+template <typename T>
+void DeletePointer(T* obj) {
+  delete obj;
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CALLBACK_HELPERS_H_

include/base/cef_callback_list.h

@@ -28,16 +28,60 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// OVERVIEW:
+//
+// A container for a list of callbacks. Provides callers the ability to manually
+// or automatically unregister callbacks at any time, including during callback
+// notification.
+//
+// TYPICAL USAGE:
+//
+// class MyWidget {
+//  public:
+//   using CallbackList = base::RepeatingCallbackList<void(const Foo&)>;
+//
+//   // Registers |cb| to be called whenever NotifyFoo() is executed.
+//   CallbackListSubscription RegisterCallback(CallbackList::CallbackType cb) {
+//     return callback_list_.Add(std::move(cb));
+//   }
+//
+//  private:
+//   // Calls all registered callbacks, with |foo| as the supplied arg.
+//   void NotifyFoo(const Foo& foo) {
+//     callback_list_.Notify(foo);
+//   }
+//
+//   CallbackList callback_list_;
+// };
+//
+//
+// class MyWidgetListener {
+//  private:
+//   void OnFoo(const Foo& foo) {
+//     // Called whenever MyWidget::NotifyFoo() is executed, unless
+//     // |foo_subscription_| has been destroyed.
+//   }
+//
+//   // Automatically deregisters the callback when deleted (e.g. in
+//   // ~MyWidgetListener()).  Unretained(this) is safe here since the
+//   // ScopedClosureRunner does not outlive |this|.
+//   CallbackListSubscription foo_subscription_ =
+//       MyWidget::Get()->RegisterCallback(
+//           base::BindRepeating(&MyWidgetListener::OnFoo,
+//                               base::Unretained(this)));
+// };
+//
+// UNSUPPORTED:
+//
+// * Destroying the CallbackList during callback notification.
+//
+// This is possible to support, but not currently necessary.
+
 #ifndef CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
 #define CEF_INCLUDE_BASE_CEF_CALLBACK_LIST_H_
 #pragma once
 
-#if defined(BASE_CALLBACK_LIST_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/callback_list.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -45,402 +89,304 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
+#include <algorithm>
 #include <list>
+#include <memory>
+#include <utility>
 
-#include "include/base/cef_basictypes.h"
+#include "include/base/cef_auto_reset.h"
-#include "include/base/cef_build.h"
+#include "include/base/cef_bind.h"
 #include "include/base/cef_callback.h"
+#include "include/base/cef_callback_helpers.h"
+#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
-#include "include/base/cef_macros.h"
+#include "include/base/cef_weak_ptr.h"
-#include "include/base/cef_scoped_ptr.h"
-#include "include/base/internal/cef_callback_internal.h"
-
-// OVERVIEW:
-//
-// A container for a list of callbacks.  Unlike a normal STL vector or list,
-// this container can be modified during iteration without invalidating the
-// iterator. It safely handles the case of a callback removing itself
-// or another callback from the list while callbacks are being run.
-//
-// TYPICAL USAGE:
-//
-// class MyWidget {
-//  public:
-//   ...
-//
-//   typedef base::Callback<void(const Foo&)> OnFooCallback;
-//
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
-//   RegisterCallback(const OnFooCallback& cb) {
-//     return callback_list_.Add(cb);
-//   }
-//
-//  private:
-//   void NotifyFoo(const Foo& foo) {
-//      callback_list_.Notify(foo);
-//   }
-//
-//   base::CallbackList<void(const Foo&)> callback_list_;
-//
-//   DISALLOW_COPY_AND_ASSIGN(MyWidget);
-// };
-//
-//
-// class MyWidgetListener {
-//  public:
-//   MyWidgetListener::MyWidgetListener() {
-//     foo_subscription_ = MyWidget::GetCurrent()->RegisterCallback(
-//             base::Bind(&MyWidgetListener::OnFoo, this)));
-//   }
-//
-//   MyWidgetListener::~MyWidgetListener() {
-//      // Subscription gets deleted automatically and will deregister
-//      // the callback in the process.
-//   }
-//
-//  private:
-//   void OnFoo(const Foo& foo) {
-//     // Do something.
-//   }
-//
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
-//       foo_subscription_;
-//
-//   DISALLOW_COPY_AND_ASSIGN(MyWidgetListener);
-// };
 
 namespace base {
+namespace internal {
+template <typename CallbackListImpl>
+class CallbackListBase;
+}  // namespace internal
 
-namespace cef_internal {
+template <typename Signature>
+class OnceCallbackList;
 
-template <typename CallbackType>
+template <typename Signature>
-class CallbackListBase {
+class RepeatingCallbackList;
+
+// A trimmed-down version of ScopedClosureRunner that can be used to guarantee a
+// closure is run on destruction. This is designed to be used by
+// CallbackListBase to run CancelCallback() when this subscription dies;
+// consumers can avoid callbacks on dead objects by ensuring the subscription
+// returned by CallbackListBase::Add() does not outlive the bound object in the
+// callback. A typical way to do this is to bind a callback to a member function
+// on `this` and store the returned subscription as a member variable.
+class CallbackListSubscription {
  public:
-  class Subscription {
+  CallbackListSubscription();
-   public:
+  CallbackListSubscription(CallbackListSubscription&& subscription);
-    Subscription(CallbackListBase<CallbackType>* list,
+  CallbackListSubscription& operator=(CallbackListSubscription&& subscription);
-                 typename std::list<CallbackType>::iterator iter)
+  ~CallbackListSubscription();
-        : list_(list), iter_(iter) {}
 
-    ~Subscription() {
+  explicit operator bool() const { return !!closure_; }
-      if (list_->active_iterator_count_) {
-        iter_->Reset();
-      } else {
-        list_->callbacks_.erase(iter_);
-        if (!list_->removal_callback_.is_null())
-          list_->removal_callback_.Run();
-      }
-    }
 
  private:
-    CallbackListBase<CallbackType>* list_;
+  template <typename T>
-    typename std::list<CallbackType>::iterator iter_;
+  friend class internal::CallbackListBase;
 
-    DISALLOW_COPY_AND_ASSIGN(Subscription);
+  explicit CallbackListSubscription(base::OnceClosure closure);
-  };
 
-  // Add a callback to the list. The callback will remain registered until the
+  void Run();
-  // returned Subscription is destroyed, which must occur before the
+
-  // CallbackList is destroyed.
+  OnceClosure closure_;
-  scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
+};
+
+namespace internal {
+
+// From base/stl_util.h.
+template <class T, class Allocator, class Predicate>
+size_t EraseIf(std::list<T, Allocator>& container, Predicate pred) {
+  size_t old_size = container.size();
+  container.remove_if(pred);
+  return old_size - container.size();
+}
+
+// A traits class to break circular type dependencies between CallbackListBase
+// and its subclasses.
+template <typename CallbackList>
+struct CallbackListTraits;
+
+// NOTE: It's important that Callbacks provide iterator stability when items are
+// added to the end, so e.g. a std::vector<> is not suitable here.
+template <typename Signature>
+struct CallbackListTraits<OnceCallbackList<Signature>> {
+  using CallbackType = OnceCallback<Signature>;
+  using Callbacks = std::list<CallbackType>;
+};
+template <typename Signature>
+struct CallbackListTraits<RepeatingCallbackList<Signature>> {
+  using CallbackType = RepeatingCallback<Signature>;
+  using Callbacks = std::list<CallbackType>;
+};
+
+template <typename CallbackListImpl>
+class CallbackListBase {
+ public:
+  using CallbackType =
+      typename CallbackListTraits<CallbackListImpl>::CallbackType;
+  static_assert(IsBaseCallback<CallbackType>::value, "");
+
+  // TODO(crbug.com/1103086): Update references to use this directly and by
+  // value, then remove.
+  using Subscription = CallbackListSubscription;
+
+  CallbackListBase() = default;
+  CallbackListBase(const CallbackListBase&) = delete;
+  CallbackListBase& operator=(const CallbackListBase&) = delete;
+
+  ~CallbackListBase() {
+    // Destroying the list during iteration is unsupported and will cause a UAF.
+    CHECK(!iterating_);
+  }
+
+  // Registers |cb| for future notifications. Returns a CallbackListSubscription
+  // whose destruction will cancel |cb|.
+  CallbackListSubscription Add(CallbackType cb) WARN_UNUSED_RESULT {
     DCHECK(!cb.is_null());
-    return scoped_ptr<Subscription>(
+    return CallbackListSubscription(base::BindOnce(
-        new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
+        &CallbackListBase::CancelCallback, weak_ptr_factory_.GetWeakPtr(),
+        callbacks_.insert(callbacks_.end(), std::move(cb))));
   }
 
-  // Sets a callback which will be run when a subscription list is changed.
+  // Registers |cb| for future notifications. Provides no way for the caller to
-  void set_removal_callback(const Closure& callback) {
+  // cancel, so this is only safe for cases where the callback is guaranteed to
-    removal_callback_ = callback;
+  // live at least as long as this list (e.g. if it's bound on the same object
+  // that owns the list).
+  // TODO(pkasting): Attempt to use Add() instead and see if callers can relax
+  // other lifetime/ordering mechanisms as a result.
+  void AddUnsafe(CallbackType cb) {
+    DCHECK(!cb.is_null());
+    callbacks_.push_back(std::move(cb));
   }
 
-  // Returns true if there are no subscriptions. This is only valid to call when
+  // Registers |removal_callback| to be run after elements are removed from the
-  // not looping through the list.
+  // list of registered callbacks.
-  bool empty() {
+  void set_removal_callback(const RepeatingClosure& removal_callback) {
-    DCHECK_EQ(0, active_iterator_count_);
+    removal_callback_ = removal_callback;
-    return callbacks_.empty();
+  }
+
+  // Returns whether the list of registered callbacks is empty (from an external
+  // perspective -- meaning no remaining callbacks are live).
+  bool empty() const {
+    return std::all_of(callbacks_.cbegin(), callbacks_.cend(),
+                       [](const auto& callback) { return callback.is_null(); });
+  }
+
+  // Calls all registered callbacks that are not canceled beforehand. If any
+  // callbacks are unregistered, notifies any registered removal callback at the
+  // end.
+  //
+  // Arguments must be copyable, since they must be supplied to all callbacks.
+  // Move-only types would be destructively modified by passing them to the
+  // first callback and not reach subsequent callbacks as intended.
+  //
+  // Notify() may be called re-entrantly, in which case the nested call
+  // completes before the outer one continues. Callbacks are only ever added at
+  // the end and canceled callbacks are not pruned from the list until the
+  // outermost iteration completes, so existing iterators should never be
+  // invalidated. However, this does mean that a callback added during a nested
+  // call can be notified by outer calls -- meaning it will be notified about
+  // things that happened before it was added -- if its subscription outlives
+  // the reentrant Notify() call.
+  template <typename... RunArgs>
+  void Notify(RunArgs&&... args) {
+    if (empty())
+      return;  // Nothing to do.
+
+    {
+      AutoReset<bool> iterating(&iterating_, true);
+
+      // Skip any callbacks that are canceled during iteration.
+      // NOTE: Since RunCallback() may call Add(), it's not safe to cache the
+      // value of callbacks_.end() across loop iterations.
+      const auto next_valid = [this](const auto it) {
+        return std::find_if_not(it, callbacks_.end(), [](const auto& callback) {
+          return callback.is_null();
+        });
+      };
+      for (auto it = next_valid(callbacks_.begin()); it != callbacks_.end();
+           it = next_valid(it))
+        // NOTE: Intentionally does not call std::forward<RunArgs>(args)...,
+        // since that would allow move-only arguments.
+        static_cast<CallbackListImpl*>(this)->RunCallback(it++, args...);
+    }
+
+    // Re-entrant invocations shouldn't prune anything from the list. This can
+    // invalidate iterators from underneath higher call frames. It's safe to
+    // simply do nothing, since the outermost frame will continue through here
+    // and prune all null callbacks below.
+    if (iterating_)
+      return;
+
+    // Any null callbacks remaining in the list were canceled due to
+    // Subscription destruction during iteration, and can safely be erased now.
+    const size_t erased_callbacks =
+        EraseIf(callbacks_, [](const auto& cb) { return cb.is_null(); });
+
+    // Run |removal_callback_| if any callbacks were canceled. Note that we
+    // cannot simply compare list sizes before and after iterating, since
+    // notification may result in Add()ing new callbacks as well as canceling
+    // them. Also note that if this is a OnceCallbackList, the OnceCallbacks
+    // that were executed above have all been removed regardless of whether
+    // they're counted in |erased_callbacks_|.
+    if (removal_callback_ &&
+        (erased_callbacks || IsOnceCallback<CallbackType>::value))
+      removal_callback_.Run();  // May delete |this|!
   }
 
  protected:
-  // An iterator class that can be used to access the list of callbacks.
+  using Callbacks = typename CallbackListTraits<CallbackListImpl>::Callbacks;
-  class Iterator {
-   public:
-    explicit Iterator(CallbackListBase<CallbackType>* list)
-        : list_(list), list_iter_(list_->callbacks_.begin()) {
-      ++list_->active_iterator_count_;
-    }
 
-    Iterator(const Iterator& iter)
+  // Holds non-null callbacks, which will be called during Notify().
-        : list_(iter.list_), list_iter_(iter.list_iter_) {
+  Callbacks callbacks_;
-      ++list_->active_iterator_count_;
-    }
-
-    ~Iterator() {
-      if (list_ && --list_->active_iterator_count_ == 0) {
-        list_->Compact();
-      }
-    }
-
-    CallbackType* GetNext() {
-      while ((list_iter_ != list_->callbacks_.end()) && list_iter_->is_null())
-        ++list_iter_;
-
-      CallbackType* cb = NULL;
-      if (list_iter_ != list_->callbacks_.end()) {
-        cb = &(*list_iter_);
-        ++list_iter_;
-      }
-      return cb;
-    }
 
  private:
-    CallbackListBase<CallbackType>* list_;
+  // Cancels the callback pointed to by |it|, which is guaranteed to be valid.
-    typename std::list<CallbackType>::iterator list_iter_;
+  void CancelCallback(const typename Callbacks::iterator& it) {
-  };
+    if (static_cast<CallbackListImpl*>(this)->CancelNullCallback(it))
+      return;
 
-  CallbackListBase() : active_iterator_count_(0) {}
+    if (iterating_) {
-
+      // Calling erase() here is unsafe, since the loop in Notify() may be
-  ~CallbackListBase() {
+      // referencing this same iterator, e.g. if adjacent callbacks'
-    DCHECK_EQ(0, active_iterator_count_);
+      // Subscriptions are both destroyed when the first one is Run().  Just
-    DCHECK_EQ(0U, callbacks_.size());
+      // reset the callback and let Notify() clean it up at the end.
-  }
+      it->Reset();
-
-  // Returns an instance of a CallbackListBase::Iterator which can be used
-  // to run callbacks.
-  Iterator GetIterator() { return Iterator(this); }
-
-  // Compact the list: remove any entries which were NULLed out during
-  // iteration.
-  void Compact() {
-    typename std::list<CallbackType>::iterator it = callbacks_.begin();
-    bool updated = false;
-    while (it != callbacks_.end()) {
-      if ((*it).is_null()) {
-        updated = true;
-        it = callbacks_.erase(it);
     } else {
-        ++it;
+      callbacks_.erase(it);
-      }
+      if (removal_callback_)
-
+        removal_callback_.Run();  // May delete |this|!
-      if (updated && !removal_callback_.is_null())
-        removal_callback_.Run();
     }
   }
 
- private:
+  // Set while Notify() is traversing |callbacks_|.  Used primarily to avoid
-  std::list<CallbackType> callbacks_;
+  // invalidating iterators that may be in use.
-  int active_iterator_count_;
+  bool iterating_ = false;
-  Closure removal_callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
+  // Called after elements are removed from |callbacks_|.
+  RepeatingClosure removal_callback_;
+
+  WeakPtrFactory<CallbackListBase> weak_ptr_factory_{this};
 };
 
-}  // namespace cef_internal
+}  // namespace internal
-
-template <typename Sig>
-class CallbackList;
-
-template <>
-class CallbackList<void(void)>
-    : public cef_internal::CallbackListBase<Callback<void(void)>> {
- public:
-  typedef Callback<void(void)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify() {
-    cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run();
-    }
-  }
 
+template <typename Signature>
+class OnceCallbackList
+    : public internal::CallbackListBase<OnceCallbackList<Signature>> {
  private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+  friend internal::CallbackListBase<OnceCallbackList>;
+  using Traits = internal::CallbackListTraits<OnceCallbackList>;
+
+  // Runs the current callback, which may cancel it or any other callbacks.
+  template <typename... RunArgs>
+  void RunCallback(typename Traits::Callbacks::iterator it, RunArgs&&... args) {
+    // OnceCallbacks still have Subscriptions with outstanding iterators;
+    // splice() removes them from |callbacks_| without invalidating those.
+    null_callbacks_.splice(null_callbacks_.end(), this->callbacks_, it);
+
+    // NOTE: Intentionally does not call std::forward<RunArgs>(args)...; see
+    // comments in Notify().
+    std::move(*it).Run(args...);
+  }
+
+  // If |it| refers to an already-canceled callback, does any necessary cleanup
+  // and returns true.  Otherwise returns false.
+  bool CancelNullCallback(const typename Traits::Callbacks::iterator& it) {
+    if (it->is_null()) {
+      null_callbacks_.erase(it);
+      return true;
+    }
+    return false;
+  }
+
+  // Holds null callbacks whose Subscriptions are still alive, so the
+  // Subscriptions will still contain valid iterators.  Only needed for
+  // OnceCallbacks, since RepeatingCallbacks are not canceled except by
+  // Subscription destruction.
+  typename Traits::Callbacks null_callbacks_;
 };
 
-template <typename A1>
+template <typename Signature>
-class CallbackList<void(A1)>
+class RepeatingCallbackList
-    : public cef_internal::CallbackListBase<Callback<void(A1)>> {
+    : public internal::CallbackListBase<RepeatingCallbackList<Signature>> {
- public:
-  typedef Callback<void(A1)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1);
-    }
-  }
-
  private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
+  friend internal::CallbackListBase<RepeatingCallbackList>;
+  using Traits = internal::CallbackListTraits<RepeatingCallbackList>;
+  // Runs the current callback, which may cancel it or any other callbacks.
+  template <typename... RunArgs>
+  void RunCallback(typename Traits::Callbacks::iterator it, RunArgs&&... args) {
+    // NOTE: Intentionally does not call std::forward<RunArgs>(args)...; see
+    // comments in Notify().
+    it->Run(args...);
+  }
+
+  // If |it| refers to an already-canceled callback, does any necessary cleanup
+  // and returns true.  Otherwise returns false.
+  bool CancelNullCallback(const typename Traits::Callbacks::iterator& it) {
+    // Because at most one Subscription can point to a given callback, and
+    // RepeatingCallbacks are only reset by CancelCallback(), no one should be
+    // able to request cancellation of a canceled RepeatingCallback.
+    DCHECK(!it->is_null());
+    return false;
+  }
 };
 
-template <typename A1, typename A2>
+// Syntactic sugar to parallel that used for Callbacks.
-class CallbackList<void(A1, A2)>
+// ClosureList explicitly not provided since it is not used, and CallbackList
-    : public cef_internal::CallbackListBase<Callback<void(A1, A2)>> {
+// is deprecated. {Once,Repeating}ClosureList should instead be used.
- public:
+using OnceClosureList = OnceCallbackList<void()>;
-  typedef Callback<void(A1, A2)> CallbackType;
+using RepeatingClosureList = RepeatingCallbackList<void()>;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3>
-class CallbackList<void(A1, A2, A3)>
-    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)>> {
- public:
-  typedef Callback<void(A1, A2, A3)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4>
-class CallbackList<void(A1, A2, A3, A4)>
-    : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)>> {
- public:
-  typedef Callback<void(A1, A2, A3, A4)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5>
-class CallbackList<void(A1, A2, A3, A4, A5)>
-    : public cef_internal::CallbackListBase<
-          Callback<void(A1, A2, A3, A4, A5)>> {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6>
-class CallbackList<void(A1, A2, A3, A4, A5, A6)>
-    : public cef_internal::CallbackListBase<
-          Callback<void(A1, A2, A3, A4, A5, A6)>> {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
-              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5, a6);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
-
-template <typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6,
-          typename A7>
-class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)>
-    : public cef_internal::CallbackListBase<
-          Callback<void(A1, A2, A3, A4, A5, A6, A7)>> {
- public:
-  typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;
-
-  CallbackList() {}
-
-  void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
-              typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
-              typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
-              typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
-              typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
-              typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
-              typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) {
-    typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
-        this->GetIterator();
-    CallbackType* cb;
-    while ((cb = it.GetNext()) != NULL) {
-      cb->Run(a1, a2, a3, a4, a5, a6, a7);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CallbackList);
-};
 
 }  // namespace base
 

include/base/cef_cancelable_callback.h

@@ -27,7 +27,7 @@
 // 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.
-//
+
 // CancelableCallback is a wrapper around base::Callback that allows
 // cancellation of a callback. CancelableCallback takes a reference on the
 // wrapped callback until this object is destroyed or Reset()/Cancel() are
@@ -52,29 +52,26 @@
 // to the message loop, the intensive test runs, the message loop is run,
 // then the callback is cancelled.
 //
+// RunLoop run_loop;
+//
 // void TimeoutCallback(const std::string& timeout_message) {
 //   FAIL() << timeout_message;
-//   MessageLoop::current()->QuitWhenIdle();
+//   run_loop.QuitWhenIdle();
 // }
 //
-// CancelableClosure timeout(base::Bind(&TimeoutCallback, "Test timed out."));
+// CancelableOnceClosure timeout(
-// MessageLoop::current()->PostDelayedTask(FROM_HERE, timeout.callback(),
+//     base::BindOnce(&TimeoutCallback, "Test timed out."));
-//                                         4000)  // 4 seconds to run.
+// ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, timeout.callback(),
+//                                                TimeDelta::FromSeconds(4));
 // RunIntensiveTest();
-// MessageLoop::current()->Run();
+// run_loop.Run();
 // timeout.Cancel();  // Hopefully this is hit before the timeout callback runs.
-//
 
 #ifndef CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
 #define CEF_INCLUDE_BASE_CEF_CANCELABLE_CALLBACK_H_
 #pragma once
 
-#if defined(BASE_CANCELABLE_CALLBACK_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/cancelable_callback.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -82,37 +79,36 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
+#include <utility>
+
 #include "include/base/cef_bind.h"
-#include "include/base/cef_build.h"
 #include "include/base/cef_callback.h"
+#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
-#include "include/base/cef_macros.h"
 #include "include/base/cef_weak_ptr.h"
 #include "include/base/internal/cef_callback_internal.h"
 
 namespace base {
+namespace internal {
 
-template <typename Sig>
+template <typename CallbackType>
-class CancelableCallback;
+class CancelableCallbackImpl {
-
-template <>
-class CancelableCallback<void(void)> {
  public:
-  CancelableCallback() : weak_factory_(this) {}
+  CancelableCallbackImpl() = default;
+  CancelableCallbackImpl(const CancelableCallbackImpl&) = delete;
+  CancelableCallbackImpl& operator=(const CancelableCallbackImpl&) = delete;
 
   // |callback| must not be null.
-  explicit CancelableCallback(const base::Callback<void(void)>& callback)
+  explicit CancelableCallbackImpl(CallbackType callback)
-      : weak_factory_(this), callback_(callback) {
+      : callback_(std::move(callback)) {
-    DCHECK(!callback.is_null());
+    DCHECK(callback_);
-    InitializeForwarder();
   }
 
-  ~CancelableCallback() {}
+  ~CancelableCallbackImpl() = default;
 
   // Cancels and drops the reference to the wrapped callback.
   void Cancel() {
-    weak_factory_.InvalidateWeakPtrs();
+    weak_ptr_factory_.InvalidateWeakPtrs();
-    forwarder_.Reset();
     callback_.Reset();
   }
 
@@ -121,170 +117,66 @@ class CancelableCallback<void(void)> {
 
   // Sets |callback| as the closure that may be cancelled. |callback| may not
   // be null. Outstanding and any previously wrapped callbacks are cancelled.
-  void Reset(const base::Callback<void(void)>& callback) {
+  void Reset(CallbackType callback) {
-    DCHECK(!callback.is_null());
+    DCHECK(callback);
-
     // Outstanding tasks (e.g., posted to a message loop) must not be called.
     Cancel();
-
+    callback_ = std::move(callback);
-    // |forwarder_| is no longer valid after Cancel(), so re-bind.
-    InitializeForwarder();
-
-    callback_ = callback;
   }
 
   // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(void)>& callback() const { return forwarder_; }
+  CallbackType callback() const {
+    if (!callback_)
+      return CallbackType();
+    CallbackType forwarder;
+    MakeForwarder(&forwarder);
+    return forwarder;
+  }
 
  private:
-  void Forward() { callback_.Run(); }
+  template <typename... Args>
-
+  void MakeForwarder(RepeatingCallback<void(Args...)>* out) const {
-  // Helper method to bind |forwarder_| using a weak pointer from
+    using ForwarderType = void (CancelableCallbackImpl::*)(Args...);
-  // |weak_factory_|.
+    ForwarderType forwarder = &CancelableCallbackImpl::ForwardRepeating;
-  void InitializeForwarder() {
+    *out = BindRepeating(forwarder, weak_ptr_factory_.GetWeakPtr());
-    forwarder_ = base::Bind(&CancelableCallback<void(void)>::Forward,
-                            weak_factory_.GetWeakPtr());
   }
 
-  // Used to ensure Forward() is not run when this object is destroyed.
+  template <typename... Args>
-  base::WeakPtrFactory<CancelableCallback<void(void)>> weak_factory_;
+  void MakeForwarder(OnceCallback<void(Args...)>* out) const {
+    using ForwarderType = void (CancelableCallbackImpl::*)(Args...);
+    ForwarderType forwarder = &CancelableCallbackImpl::ForwardOnce;
+    *out = BindOnce(forwarder, weak_ptr_factory_.GetWeakPtr());
+  }
 
-  // The wrapper closure.
+  template <typename... Args>
-  base::Callback<void(void)> forwarder_;
+  void ForwardRepeating(Args... args) {
+    callback_.Run(std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  void ForwardOnce(Args... args) {
+    weak_ptr_factory_.InvalidateWeakPtrs();
+    std::move(callback_).Run(std::forward<Args>(args)...);
+  }
 
   // The stored closure that may be cancelled.
-  base::Callback<void(void)> callback_;
+  CallbackType callback_;
-
+  mutable base::WeakPtrFactory<CancelableCallbackImpl> weak_ptr_factory_{this};
-  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
 };
 
-template <typename A1>
+}  // namespace internal
-class CancelableCallback<void(A1)> {
- public:
-  CancelableCallback() : weak_factory_(this) {}
 
-  // |callback| must not be null.
+// Consider using base::WeakPtr directly instead of base::CancelableCallback for
-  explicit CancelableCallback(const base::Callback<void(A1)>& callback)
+// the task cancellation.
-      : weak_factory_(this), callback_(callback) {
+template <typename Signature>
-    DCHECK(!callback.is_null());
+using CancelableOnceCallback =
-    InitializeForwarder();
+    internal::CancelableCallbackImpl<OnceCallback<Signature>>;
-  }
+using CancelableOnceClosure = CancelableOnceCallback<void()>;
 
-  ~CancelableCallback() {}
+template <typename Signature>
-
+using CancelableRepeatingCallback =
-  // Cancels and drops the reference to the wrapped callback.
+    internal::CancelableCallbackImpl<RepeatingCallback<Signature>>;
-  void Cancel() {
+using CancelableRepeatingClosure = CancelableRepeatingCallback<void()>;
-    weak_factory_.InvalidateWeakPtrs();
-    forwarder_.Reset();
-    callback_.Reset();
-  }
-
-  // Returns true if the wrapped callback has been cancelled.
-  bool IsCancelled() const { return callback_.is_null(); }
-
-  // Sets |callback| as the closure that may be cancelled. |callback| may not
-  // be null. Outstanding and any previously wrapped callbacks are cancelled.
-  void Reset(const base::Callback<void(A1)>& callback) {
-    DCHECK(!callback.is_null());
-
-    // Outstanding tasks (e.g., posted to a message loop) must not be called.
-    Cancel();
-
-    // |forwarder_| is no longer valid after Cancel(), so re-bind.
-    InitializeForwarder();
-
-    callback_ = callback;
-  }
-
-  // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(A1)>& callback() const { return forwarder_; }
-
- private:
-  void Forward(A1 a1) const { callback_.Run(a1); }
-
-  // Helper method to bind |forwarder_| using a weak pointer from
-  // |weak_factory_|.
-  void InitializeForwarder() {
-    forwarder_ = base::Bind(&CancelableCallback<void(A1)>::Forward,
-                            weak_factory_.GetWeakPtr());
-  }
-
-  // Used to ensure Forward() is not run when this object is destroyed.
-  base::WeakPtrFactory<CancelableCallback<void(A1)>> weak_factory_;
-
-  // The wrapper closure.
-  base::Callback<void(A1)> forwarder_;
-
-  // The stored closure that may be cancelled.
-  base::Callback<void(A1)> callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
-};
-
-template <typename A1, typename A2>
-class CancelableCallback<void(A1, A2)> {
- public:
-  CancelableCallback() : weak_factory_(this) {}
-
-  // |callback| must not be null.
-  explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
-      : weak_factory_(this), callback_(callback) {
-    DCHECK(!callback.is_null());
-    InitializeForwarder();
-  }
-
-  ~CancelableCallback() {}
-
-  // Cancels and drops the reference to the wrapped callback.
-  void Cancel() {
-    weak_factory_.InvalidateWeakPtrs();
-    forwarder_.Reset();
-    callback_.Reset();
-  }
-
-  // Returns true if the wrapped callback has been cancelled.
-  bool IsCancelled() const { return callback_.is_null(); }
-
-  // Sets |callback| as the closure that may be cancelled. |callback| may not
-  // be null. Outstanding and any previously wrapped callbacks are cancelled.
-  void Reset(const base::Callback<void(A1, A2)>& callback) {
-    DCHECK(!callback.is_null());
-
-    // Outstanding tasks (e.g., posted to a message loop) must not be called.
-    Cancel();
-
-    // |forwarder_| is no longer valid after Cancel(), so re-bind.
-    InitializeForwarder();
-
-    callback_ = callback;
-  }
-
-  // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(A1, A2)>& callback() const { return forwarder_; }
-
- private:
-  void Forward(A1 a1, A2 a2) const { callback_.Run(a1, a2); }
-
-  // Helper method to bind |forwarder_| using a weak pointer from
-  // |weak_factory_|.
-  void InitializeForwarder() {
-    forwarder_ = base::Bind(&CancelableCallback<void(A1, A2)>::Forward,
-                            weak_factory_.GetWeakPtr());
-  }
-
-  // Used to ensure Forward() is not run when this object is destroyed.
-  base::WeakPtrFactory<CancelableCallback<void(A1, A2)>> weak_factory_;
-
-  // The wrapper closure.
-  base::Callback<void(A1, A2)> forwarder_;
-
-  // The stored closure that may be cancelled.
-  base::Callback<void(A1, A2)> callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
-};
-
-typedef CancelableCallback<void(void)> CancelableClosure;
 
 }  // namespace base
 

include/base/cef_compiler_specific.h

@@ -0,0 +1,411 @@
+// Copyright (c) 2021 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.
+
+#ifndef CEF_INCLUDE_BASE_CEF_COMPILER_SPECIFIC_H_
+#define CEF_INCLUDE_BASE_CEF_COMPILER_SPECIFIC_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/compiler_specific.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"
+
+// This is a wrapper around `__has_cpp_attribute`, which can be used to test for
+// the presence of an attribute. In case the compiler does not support this
+// macro it will simply evaluate to 0.
+//
+// References:
+// https://wg21.link/sd6#testing-for-the-presence-of-an-attribute-__has_cpp_attribute
+// https://wg21.link/cpp.cond#:__has_cpp_attribute
+#if defined(__has_cpp_attribute)
+#define HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#define HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+// A wrapper around `__has_builtin`, similar to HAS_CPP_ATTRIBUTE.
+#if defined(__has_builtin)
+#define HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define HAS_BUILTIN(x) 0
+#endif
+
+// __has_feature and __has_attribute don't exist for MSVC.
+#if !defined(__has_feature)
+#define __has_feature(x) 0
+#endif  // !defined(__has_feature)
+
+#if !defined(__has_attribute)
+#define __has_attribute(x) 0
+#endif  // !defined(__has_attribute)
+
+// Annotate a function indicating it should not be inlined.
+// Use like:
+//   NOINLINE void DoStuff() { ... }
+#if defined(COMPILER_GCC)
+#define NOINLINE __attribute__((noinline))
+#elif defined(COMPILER_MSVC)
+#define NOINLINE __declspec(noinline)
+#else
+#define NOINLINE
+#endif
+
+#if defined(COMPILER_GCC) && defined(NDEBUG)
+#define ALWAYS_INLINE inline __attribute__((__always_inline__))
+#elif defined(COMPILER_MSVC) && defined(NDEBUG)
+#define ALWAYS_INLINE __forceinline
+#else
+#define ALWAYS_INLINE inline
+#endif
+
+// Annotate a function indicating it should never be tail called. Useful to make
+// sure callers of the annotated function are never omitted from call-stacks.
+// To provide the complementary behavior (prevent the annotated function from
+// being omitted) look at NOINLINE. Also note that this doesn't prevent code
+// folding of multiple identical caller functions into a single signature. To
+// prevent code folding, see NO_CODE_FOLDING() in base/debug/alias.h.
+// Use like:
+//   void NOT_TAIL_CALLED FooBar();
+#if defined(__clang__) && __has_attribute(not_tail_called)
+#define NOT_TAIL_CALLED __attribute__((not_tail_called))
+#else
+#define NOT_TAIL_CALLED
+#endif
+
+// Specify memory alignment for structs, classes, etc.
+// Use like:
+//   class ALIGNAS(16) MyClass { ... }
+//   ALIGNAS(16) int array[4];
+//
+// In most places you can use the C++11 keyword "alignas", which is preferred.
+//
+// But compilers have trouble mixing __attribute__((...)) syntax with
+// alignas(...) syntax.
+//
+// Doesn't work in clang or gcc:
+//   struct alignas(16) __attribute__((packed)) S { char c; };
+// Works in clang but not gcc:
+//   struct __attribute__((packed)) alignas(16) S2 { char c; };
+// Works in clang and gcc:
+//   struct alignas(16) S3 { char c; } __attribute__((packed));
+//
+// There are also some attributes that must be specified *before* a class
+// definition: visibility (used for exporting functions/classes) is one of
+// these attributes. This means that it is not possible to use alignas() with a
+// class that is marked as exported.
+#if defined(COMPILER_MSVC)
+#define ALIGNAS(byte_alignment) __declspec(align(byte_alignment))
+#elif defined(COMPILER_GCC)
+#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
+#endif
+
+// In case the compiler supports it NO_UNIQUE_ADDRESS evaluates to the C++20
+// attribute [[no_unique_address]]. This allows annotating data members so that
+// they need not have an address distinct from all other non-static data members
+// of its class.
+//
+// References:
+// * https://en.cppreference.com/w/cpp/language/attributes/no_unique_address
+// * https://wg21.link/dcl.attr.nouniqueaddr
+#if HAS_CPP_ATTRIBUTE(no_unique_address)
+#define NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#define NO_UNIQUE_ADDRESS
+#endif
+
+// Tell the compiler a function is using a printf-style format string.
+// |format_param| is the one-based index of the format string parameter;
+// |dots_param| is the one-based index of the "..." parameter.
+// For v*printf functions (which take a va_list), pass 0 for dots_param.
+// (This is undocumented but matches what the system C headers do.)
+// For member functions, the implicit this parameter counts as index 1.
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define PRINTF_FORMAT(format_param, dots_param) \
+  __attribute__((format(printf, format_param, dots_param)))
+#else
+#define PRINTF_FORMAT(format_param, dots_param)
+#endif
+
+// WPRINTF_FORMAT is the same, but for wide format strings.
+// This doesn't appear to yet be implemented in any compiler.
+// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38308 .
+#define WPRINTF_FORMAT(format_param, dots_param)
+// If available, it would look like:
+//   __attribute__((format(wprintf, format_param, dots_param)))
+
+// Sanitizers annotations.
+#if defined(__has_attribute)
+#if __has_attribute(no_sanitize)
+#define NO_SANITIZE(what) __attribute__((no_sanitize(what)))
+#endif
+#endif
+#if !defined(NO_SANITIZE)
+#define NO_SANITIZE(what)
+#endif
+
+// MemorySanitizer annotations.
+#if defined(MEMORY_SANITIZER) && !defined(OS_NACL)
+#include <sanitizer/msan_interface.h>
+
+// Mark a memory region fully initialized.
+// Use this to annotate code that deliberately reads uninitialized data, for
+// example a GC scavenging root set pointers from the stack.
+#define MSAN_UNPOISON(p, size) __msan_unpoison(p, size)
+
+// Check a memory region for initializedness, as if it was being used here.
+// If any bits are uninitialized, crash with an MSan report.
+// Use this to sanitize data which MSan won't be able to track, e.g. before
+// passing data to another process via shared memory.
+#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \
+  __msan_check_mem_is_initialized(p, size)
+#else  // MEMORY_SANITIZER
+#define MSAN_UNPOISON(p, size)
+#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size)
+#endif  // MEMORY_SANITIZER
+
+// DISABLE_CFI_PERF -- Disable Control Flow Integrity for perf reasons.
+#if !defined(DISABLE_CFI_PERF)
+#if defined(__clang__) && defined(OFFICIAL_BUILD)
+#define DISABLE_CFI_PERF __attribute__((no_sanitize("cfi")))
+#else
+#define DISABLE_CFI_PERF
+#endif
+#endif
+
+// DISABLE_CFI_ICALL -- Disable Control Flow Integrity indirect call checks.
+#if !defined(DISABLE_CFI_ICALL)
+#if defined(OS_WIN)
+// Windows also needs __declspec(guard(nocf)).
+#define DISABLE_CFI_ICALL NO_SANITIZE("cfi-icall") __declspec(guard(nocf))
+#else
+#define DISABLE_CFI_ICALL NO_SANITIZE("cfi-icall")
+#endif
+#endif
+#if !defined(DISABLE_CFI_ICALL)
+#define DISABLE_CFI_ICALL
+#endif
+
+// Macro useful for writing cross-platform function pointers.
+#if !defined(CDECL)
+#if defined(OS_WIN)
+#define CDECL __cdecl
+#else  // defined(OS_WIN)
+#define CDECL
+#endif  // defined(OS_WIN)
+#endif  // !defined(CDECL)
+
+// Macro for hinting that an expression is likely to be false.
+#if !defined(UNLIKELY)
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define UNLIKELY(x) (x)
+#endif  // defined(COMPILER_GCC)
+#endif  // !defined(UNLIKELY)
+
+#if !defined(LIKELY)
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define LIKELY(x) (x)
+#endif  // defined(COMPILER_GCC)
+#endif  // !defined(LIKELY)
+
+// Compiler feature-detection.
+// clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension
+#if defined(__has_feature)
+#define HAS_FEATURE(FEATURE) __has_feature(FEATURE)
+#else
+#define HAS_FEATURE(FEATURE) 0
+#endif
+
+// Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional.
+#if defined(__clang__)
+#define FALLTHROUGH [[clang::fallthrough]]
+#else
+#define FALLTHROUGH
+#endif
+
+#if defined(COMPILER_GCC)
+#define PRETTY_FUNCTION __PRETTY_FUNCTION__
+#elif defined(COMPILER_MSVC)
+#define PRETTY_FUNCTION __FUNCSIG__
+#else
+// See https://en.cppreference.com/w/c/language/function_definition#func
+#define PRETTY_FUNCTION __func__
+#endif
+
+#if !defined(CPU_ARM_NEON)
+#if defined(__arm__)
+#if !defined(__ARMEB__) && !defined(__ARM_EABI__) && !defined(__EABI__) && \
+    !defined(__VFP_FP__) && !defined(_WIN32_WCE) && !defined(ANDROID)
+#error Chromium does not support middle endian architecture
+#endif
+#if defined(__ARM_NEON__)
+#define CPU_ARM_NEON 1
+#endif
+#endif  // defined(__arm__)
+#endif  // !defined(CPU_ARM_NEON)
+
+#if !defined(HAVE_MIPS_MSA_INTRINSICS)
+#if defined(__mips_msa) && defined(__mips_isa_rev) && (__mips_isa_rev >= 5)
+#define HAVE_MIPS_MSA_INTRINSICS 1
+#endif
+#endif
+
+#if defined(__clang__) && __has_attribute(uninitialized)
+// Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
+// the specified variable.
+// Library-wide alternative is
+// 'configs -= [ "//build/config/compiler:default_init_stack_vars" ]' in .gn
+// file.
+//
+// See "init_stack_vars" in build/config/compiler/BUILD.gn and
+// http://crbug.com/977230
+// "init_stack_vars" is enabled for non-official builds and we hope to enable it
+// in official build in 2020 as well. The flag writes fixed pattern into
+// uninitialized parts of all local variables. In rare cases such initialization
+// is undesirable and attribute can be used:
+//   1. Degraded performance
+// In most cases compiler is able to remove additional stores. E.g. if memory is
+// never accessed or properly initialized later. Preserved stores mostly will
+// not affect program performance. However if compiler failed on some
+// performance critical code we can get a visible regression in a benchmark.
+//   2. memset, memcpy calls
+// Compiler may replaces some memory writes with memset or memcpy calls. This is
+// not -ftrivial-auto-var-init specific, but it can happen more likely with the
+// flag. It can be a problem if code is not linked with C run-time library.
+//
+// Note: The flag is security risk mitigation feature. So in future the
+// attribute uses should be avoided when possible. However to enable this
+// mitigation on the most of the code we need to be less strict now and minimize
+// number of exceptions later. So if in doubt feel free to use attribute, but
+// please document the problem for someone who is going to cleanup it later.
+// E.g. platform, bot, benchmark or test name in patch description or next to
+// the attribute.
+#define STACK_UNINITIALIZED __attribute__((uninitialized))
+#else
+#define STACK_UNINITIALIZED
+#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.
+// The expression is passed straight through if analysis isn't enabled.
+//
+// ANALYZER_SKIP_THIS_PATH() suppresses static analysis for the current
+// codepath and any other branching codepaths that might follow.
+#if defined(__clang_analyzer__)
+
+inline constexpr bool AnalyzerNoReturn() __attribute__((analyzer_noreturn)) {
+  return false;
+}
+
+inline constexpr bool AnalyzerAssumeTrue(bool arg) {
+  // AnalyzerNoReturn() is invoked and analysis is terminated if |arg| is
+  // false.
+  return arg || AnalyzerNoReturn();
+}
+
+#define ANALYZER_ASSUME_TRUE(arg) ::AnalyzerAssumeTrue(!!(arg))
+#define ANALYZER_SKIP_THIS_PATH() static_cast<void>(::AnalyzerNoReturn())
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#else  // !defined(__clang_analyzer__)
+
+#define ANALYZER_ASSUME_TRUE(arg) (arg)
+#define ANALYZER_SKIP_THIS_PATH()
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#endif  // defined(__clang_analyzer__)
+
+// Use nomerge attribute to disable optimization of merging multiple same calls.
+#if defined(__clang__) && __has_attribute(nomerge)
+#define NOMERGE [[clang::nomerge]]
+#else
+#define NOMERGE
+#endif
+
+// Marks a type as being eligible for the "trivial" ABI despite having a
+// non-trivial destructor or copy/move constructor. Such types can be relocated
+// after construction by simply copying their memory, which makes them eligible
+// to be passed in registers. The canonical example is std::unique_ptr.
+//
+// Use with caution; this has some subtle effects on constructor/destructor
+// ordering and will be very incorrect if the type relies on its address
+// remaining constant. When used as a function argument (by value), the value
+// may be constructed in the caller's stack frame, passed in a register, and
+// then used and destructed in the callee's stack frame. A similar thing can
+// occur when values are returned.
+//
+// TRIVIAL_ABI is not needed for types which have a trivial destructor and
+// copy/move constructors, such as base::TimeTicks and other POD.
+//
+// It is also not likely to be effective on types too large to be passed in one
+// or two registers on typical target ABIs.
+//
+// See also:
+//   https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
+//   https://libcxx.llvm.org/docs/DesignDocs/UniquePtrTrivialAbi.html
+#if defined(__clang__) && __has_attribute(trivial_abi)
+#define TRIVIAL_ABI [[clang::trivial_abi]]
+#else
+#define TRIVIAL_ABI
+#endif
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+// Annotate a function indicating the caller must examine the return value.
+// Use like:
+//   int foo() WARN_UNUSED_RESULT;
+// To explicitly ignore a result, use std::ignore from <tuple>.
+// Alternately use `[[nodiscard]]` with code that supports C++17.
+#undef WARN_UNUSED_RESULT
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT
+#endif
+
+// Annotate a variable indicating it's ok if the variable is not used.
+// (Typically used to silence a compiler warning when the assignment
+// is important for some other reason.)
+// Use like:
+//   int x = ...;
+//   ALLOW_UNUSED_LOCAL(x);
+// Alternately use `[[maybe_unused]]` with code that supports C++17.
+#define ALLOW_UNUSED_LOCAL(x) (void)x
+
+#endif  // CEF_INCLUDE_BASE_CEF_COMPILER_SPECIFIC_H_

include/base/cef_cxx17_backports.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2021 Marshall A. Greenblatt. Portions copyright (c) 2021
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_
+#define CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/cxx17_backports.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following was removed from Chromium in https://crrev.com/78734f77be.
+
+namespace base {
+
+// C++14 implementation of C++17's std::size():
+// http://en.cppreference.com/w/cpp/iterator/size
+template <typename Container>
+constexpr auto size(const Container& c) -> decltype(c.size()) {
+  return c.size();
+}
+
+template <typename T, size_t N>
+constexpr size_t size(const T (&array)[N]) noexcept {
+  return N;
+}
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_CXX17_BACKPORTS_H_

include/base/cef_lock.h

@@ -32,12 +32,7 @@
 #define CEF_INCLUDE_BASE_CEF_LOCK_H_
 #pragma once
 
-#if defined(BASE_SYNCHRONIZATION_LOCK_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/synchronization/lock.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -46,7 +41,6 @@
 // updated to match.
 
 #include "include/base/cef_logging.h"
-#include "include/base/cef_macros.h"
 #include "include/base/cef_platform_thread.h"
 #include "include/base/internal/cef_lock_impl.h"
 
@@ -60,6 +54,10 @@ class Lock {
  public:
 #if !DCHECK_IS_ON()  // Optimized wrapper implementation
   Lock() : lock_() {}
+
+  Lock(const Lock&) = delete;
+  Lock& operator=(const Lock&) = delete;
+
   ~Lock() {}
   void Acquire() { lock_.Lock(); }
   void Release() { lock_.Unlock(); }
@@ -116,8 +114,6 @@ class Lock {
 
   // Platform specific underlying lock implementation.
   LockImpl lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(Lock);
 };
 
 // A helper class that acquires the given Lock while the AutoLock is in scope.
@@ -131,6 +127,9 @@ class AutoLock {
     lock_.AssertAcquired();
   }
 
+  AutoLock(const AutoLock&) = delete;
+  AutoLock& operator=(const AutoLock&) = delete;
+
   ~AutoLock() {
     lock_.AssertAcquired();
     lock_.Release();
@@ -138,7 +137,6 @@ class AutoLock {
 
  private:
   Lock& lock_;
-  DISALLOW_COPY_AND_ASSIGN(AutoLock);
 };
 
 // AutoUnlock is a helper that will Release() the |lock| argument in the
@@ -151,11 +149,13 @@ class AutoUnlock {
     lock_.Release();
   }
 
+  AutoUnlock(const AutoUnlock&) = delete;
+  AutoUnlock& operator=(const AutoUnlock&) = delete;
+
   ~AutoUnlock() { lock_.Acquire(); }
 
  private:
   Lock& lock_;
-  DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
 };
 
 }  // namespace cef_internal
@@ -163,9 +163,9 @@ class AutoUnlock {
 // Implement classes in the cef_internal namespace and then expose them to the
 // base namespace. This avoids conflicts with the base.lib implementation when
 // linking sandbox support on Windows.
-using cef_internal::Lock;
 using cef_internal::AutoLock;
 using cef_internal::AutoUnlock;
+using cef_internal::Lock;
 
 }  // namespace base
 

include/base/cef_logging.h

@@ -164,7 +164,6 @@
 #include <string>
 
 #include "include/base/cef_build.h"
-#include "include/base/cef_macros.h"
 #include "include/internal/cef_logging_internal.h"
 
 namespace cef {
@@ -203,19 +202,19 @@ const LogSeverity LOG_DFATAL = LOG_FATAL;
 // by LOG() and LOG_IF, etc. Since these are used all over our code, it's
 // better to have compact code for these operations.
 #define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...)                        \
-  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO, \
+  ::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_INFO, \
                             ##__VA_ARGS__)
 #define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...)                        \
-  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING, \
+  ::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_WARNING, \
                             ##__VA_ARGS__)
 #define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...)                        \
-  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR, \
+  ::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_ERROR, \
                             ##__VA_ARGS__)
 #define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...)                        \
-  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL, \
+  ::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_FATAL, \
                             ##__VA_ARGS__)
 #define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...)                        \
-  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL, \
+  ::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_DFATAL, \
                             ##__VA_ARGS__)
 
 #define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
@@ -583,6 +582,9 @@ class LogMessage {
              LogSeverity severity,
              std::string* result);
 
+  LogMessage(const LogMessage&) = delete;
+  LogMessage& operator=(const LogMessage&) = delete;
+
   ~LogMessage();
 
   std::ostream& stream() { return stream_; }
@@ -614,8 +616,6 @@ class LogMessage {
 
   SaveLastError last_error_;
 #endif
-
-  DISALLOW_COPY_AND_ASSIGN(LogMessage);
 };
 
 // A non-macro interface to the log facility; (useful
@@ -655,6 +655,9 @@ class Win32ErrorLogMessage {
                        LogSeverity severity,
                        SystemErrorCode err);
 
+  Win32ErrorLogMessage(const Win32ErrorLogMessage&) = delete;
+  Win32ErrorLogMessage& operator=(const Win32ErrorLogMessage&) = delete;
+
   // Appends the error message before destructing the encapsulated class.
   ~Win32ErrorLogMessage();
 
@@ -663,8 +666,6 @@ class Win32ErrorLogMessage {
  private:
   SystemErrorCode err_;
   LogMessage log_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
 };
 #elif defined(OS_POSIX)
 // Appends a formatted system message of the errno type
@@ -675,6 +676,9 @@ class ErrnoLogMessage {
                   LogSeverity severity,
                   SystemErrorCode err);
 
+  ErrnoLogMessage(const ErrnoLogMessage&) = delete;
+  ErrnoLogMessage& operator=(const ErrnoLogMessage&) = delete;
+
   // Appends the error message before destructing the encapsulated class.
   ~ErrnoLogMessage();
 
@@ -683,8 +687,6 @@ class ErrnoLogMessage {
  private:
   SystemErrorCode err_;
   LogMessage log_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
 };
 #endif  // OS_WIN
 

include/base/cef_macros.h

@@ -32,189 +32,32 @@
 #define CEF_INCLUDE_BASE_CEF_MACROS_H_
 #pragma once
 
-#if defined(USING_CHROMIUM_INCLUDES)
+#if !defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-#include "base/macros.h"
-
-#else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include <stddef.h>                  // For size_t.
+// ALL DISALLOW_xxx MACROS ARE DEPRECATED; DO NOT USE IN NEW CODE.
-#include "include/base/cef_build.h"  // For COMPILER_MSVC
+// Use explicit deletions instead.  See the section on copyability/movability in
+// //styleguide/c++/c++-dos-and-donts.md for more information.
 
-#if !defined(arraysize)
+// DEPRECATED: See above. Makes a class uncopyable.
+#define DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
 
-// The arraysize(arr) macro returns the # of elements in an array arr.
+// DEPRECATED: See above. Makes a class unassignable.
-// The expression is a compile-time constant, and therefore can be
+#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
-// used in defining new arrays, for example.  If you use arraysize on
-// a pointer by mistake, you will get a compile-time error.
-//
-// One caveat is that arraysize() doesn't accept any array of an
-// anonymous type or a type defined inside a function.  In these rare
-// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
-// due to a limitation in C++'s template system.  The limitation might
-// eventually be removed, but it hasn't happened yet.
 
-// This template function declaration is used in defining arraysize.
+// DEPRECATED: See above. Makes a class uncopyable and unassignable.
-// Note that the function doesn't need an implementation, as we only
-// use its type.
-template <typename T, size_t N>
-char (&ArraySizeHelper(T (&array)[N]))[N];
-
-// That gcc wants both of these prototypes seems mysterious. VC, for
-// its part, can't decide which to use (another mystery). Matching of
-// template overloads: the final frontier.
-#ifndef _MSC_VER
-template <typename T, size_t N>
-char (&ArraySizeHelper(const T (&array)[N]))[N];
-#endif
-
-#define arraysize(array) (sizeof(ArraySizeHelper(array)))
-
-#endif  // !arraysize
-
-#if !defined(DISALLOW_COPY_AND_ASSIGN)
-
-// A macro to disallow the copy constructor and operator= functions
-// This should be used in the private: declarations for a class
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  TypeName(const TypeName&);               \
+  DISALLOW_COPY(TypeName);                 \
-  void operator=(const TypeName&)
+  DISALLOW_ASSIGN(TypeName)
 
-#endif  // !DISALLOW_COPY_AND_ASSIGN
+// DEPRECATED: See above. Disallow all implicit constructors, namely the
-
-#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
-
-// A macro to disallow all the implicit constructors, namely the
 // default constructor, copy constructor and operator= functions.
-//
-// This should be used in the private: declarations for a class
-// that wants to prevent anyone from instantiating it. This is
-// especially useful for classes containing only static methods.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
-  TypeName();                                    \
+  TypeName() = delete;                           \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
 
-#endif  // !DISALLOW_IMPLICIT_CONSTRUCTORS
-
-#if !defined(COMPILE_ASSERT)
-
-// The COMPILE_ASSERT macro can be used to verify that a compile time
-// expression is true. For example, you could use it to verify the
-// size of a static array:
-//
-//   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
-//                  content_type_names_incorrect_size);
-//
-// or to make sure a struct is smaller than a certain size:
-//
-//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
-//
-// The second argument to the macro is the name of the variable. If
-// the expression is false, most compilers will issue a warning/error
-// containing the name of the variable.
-
-#if __cplusplus >= 201103L
-
-// Under C++11, just use static_assert.
-#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
-
-#else
-
-namespace cef {
-
-template <bool>
-struct CompileAssert {};
-
-}  // namespace cef
-
-#define COMPILE_ASSERT(expr, msg)          \
-  typedef cef::CompileAssert<(bool(expr))> \
-      msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE
-
-// Implementation details of COMPILE_ASSERT:
-//
-// - COMPILE_ASSERT works by defining an array type that has -1
-//   elements (and thus is invalid) when the expression is false.
-//
-// - The simpler definition
-//
-//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
-//
-//   does not work, as gcc supports variable-length arrays whose sizes
-//   are determined at run-time (this is gcc's extension and not part
-//   of the C++ standard).  As a result, gcc fails to reject the
-//   following code with the simple definition:
-//
-//     int foo;
-//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
-//                               // not a compile-time constant.
-//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
-//   expr is a compile-time constant.  (Template arguments must be
-//   determined at compile-time.)
-//
-// - The outer parentheses in CompileAssert<(bool(expr))> are necessary
-//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
-//
-//     CompileAssert<bool(expr)>
-//
-//   instead, these compilers will refuse to compile
-//
-//     COMPILE_ASSERT(5 > 0, some_message);
-//
-//   (They seem to think the ">" in "5 > 0" marks the end of the
-//   template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
-//
-//     ((expr) ? 1 : -1).
-//
-//   This is to avoid running into a bug in MS VC 7.1, which
-//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
-
-#endif  // !(__cplusplus >= 201103L)
-
-#endif  // !defined(COMPILE_ASSERT)
-
 #endif  // !USING_CHROMIUM_INCLUDES
 
-#if !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)
-
-// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
-// The warning remains disabled until popped by MSVC_POP_WARNING.
-#define MSVC_PUSH_DISABLE_WARNING(n) \
-  __pragma(warning(push)) __pragma(warning(disable : n))
-
-// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
-// remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
-// warnings.
-#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))
-
-// Pop effects of innermost MSVC_PUSH_* macro.
-#define MSVC_POP_WARNING() __pragma(warning(pop))
-
-#endif  // !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)
-
-#if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
-#if defined(COMPILER_MSVC)
-// Allows |this| to be passed as an argument in constructor initializer lists.
-// This uses push/pop instead of the seemingly simpler suppress feature to avoid
-// having the warning be disabled for more than just |code|.
-//
-// Example usage:
-// Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {}
-//
-// Compiler warning C4355: 'this': used in base member initializer list:
-// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
-#define ALLOW_THIS_IN_INITIALIZER_LIST(code) \
-  MSVC_PUSH_DISABLE_WARNING(4355)            \
-  code MSVC_POP_WARNING()
-#else  // !COMPILER_MSVC
-#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code
-#endif  // !COMPILER_MSVC
-#endif  // !ALLOW_THIS_IN_INITIALIZER_LIST
-
 #endif  // CEF_INCLUDE_BASE_CEF_MACROS_H_

include/base/cef_move.h

@@ -1,261 +0,0 @@
-// Copyright (c) 2014 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.
-
-#ifndef CEF_INCLUDE_BASE_CEF_MOVE_H_
-#define CEF_INCLUDE_BASE_CEF_MOVE_H_
-
-#if defined(MOVE_ONLY_TYPE_FOR_CPP_03)
-// Do nothing if the macro in this header has already been defined.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
-// When building CEF include the Chromium header directly.
-#include "base/move.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.
-
-// Macro with the boilerplate that makes a type move-only in C++03.
-//
-// USAGE
-//
-// This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create
-// a "move-only" type.  Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be
-// the first line in a class declaration.
-//
-// A class using this macro must call .Pass() (or somehow be an r-value already)
-// before it can be:
-//
-//   * Passed as a function argument
-//   * Used as the right-hand side of an assignment
-//   * Returned from a function
-//
-// Each class will still need to define their own "move constructor" and "move
-// operator=" to make this useful.  Here's an example of the macro, the move
-// constructor, and the move operator= from the scoped_ptr class:
-//
-//  template <typename T>
-//  class scoped_ptr {
-//     MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
-//   public:
-//    scoped_ptr(RValue& other) : ptr_(other.release()) { }
-//    scoped_ptr& operator=(RValue& other) {
-//      swap(other);
-//      return *this;
-//    }
-//  };
-//
-// Note that the constructor must NOT be marked explicit.
-//
-// For consistency, the second parameter to the macro should always be RValue
-// unless you have a strong reason to do otherwise.  It is only exposed as a
-// macro parameter so that the move constructor and move operator= don't look
-// like they're using a phantom type.
-//
-//
-// HOW THIS WORKS
-//
-// For a thorough explanation of this technique, see:
-//
-//   http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor
-//
-// The summary is that we take advantage of 2 properties:
-//
-//   1) non-const references will not bind to r-values.
-//   2) C++ can apply one user-defined conversion when initializing a
-//      variable.
-//
-// The first lets us disable the copy constructor and assignment operator
-// by declaring private version of them with a non-const reference parameter.
-//
-// For l-values, direct initialization still fails like in
-// DISALLOW_COPY_AND_ASSIGN because the copy constructor and assignment
-// operators are private.
-//
-// For r-values, the situation is different. The copy constructor and
-// assignment operator are not viable due to (1), so we are trying to call
-// a non-existent constructor and non-existing operator= rather than a private
-// one.  Since we have not committed an error quite yet, we can provide an
-// alternate conversion sequence and a constructor.  We add
-//
-//   * a private struct named "RValue"
-//   * a user-defined conversion "operator RValue()"
-//   * a "move constructor" and "move operator=" that take the RValue& as
-//     their sole parameter.
-//
-// Only r-values will trigger this sequence and execute our "move constructor"
-// or "move operator=."  L-values will match the private copy constructor and
-// operator= first giving a "private in this context" error.  This combination
-// gives us a move-only type.
-//
-// For signaling a destructive transfer of data from an l-value, we provide a
-// method named Pass() which creates an r-value for the current instance
-// triggering the move constructor or move operator=.
-//
-// Other ways to get r-values is to use the result of an expression like a
-// function call.
-//
-// Here's an example with comments explaining what gets triggered where:
-//
-//    class Foo {
-//      MOVE_ONLY_TYPE_FOR_CPP_03(Foo, RValue);
-//
-//     public:
-//       ... API ...
-//       Foo(RValue other);           // Move constructor.
-//       Foo& operator=(RValue rhs);  // Move operator=
-//    };
-//
-//    Foo MakeFoo();  // Function that returns a Foo.
-//
-//    Foo f;
-//    Foo f_copy(f);  // ERROR: Foo(Foo&) is private in this context.
-//    Foo f_assign;
-//    f_assign = f;   // ERROR: operator=(Foo&) is private in this context.
-//
-//
-//    Foo f(MakeFoo());      // R-value so alternate conversion executed.
-//    Foo f_copy(f.Pass());  // R-value so alternate conversion executed.
-//    f = f_copy.Pass();     // R-value so alternate conversion executed.
-//
-//
-// IMPLEMENTATION SUBTLETIES WITH RValue
-//
-// The RValue struct is just a container for a pointer back to the original
-// object. It should only ever be created as a temporary, and no external
-// class should ever declare it or use it in a parameter.
-//
-// It is tempting to want to use the RValue type in function parameters, but
-// excluding the limited usage here for the move constructor and move
-// operator=, doing so would mean that the function could take both r-values
-// and l-values equially which is unexpected.  See COMPARED To Boost.Move for
-// more details.
-//
-// An alternate, and incorrect, implementation of the RValue class used by
-// Boost.Move makes RValue a fieldless child of the move-only type. RValue&
-// is then used in place of RValue in the various operators.  The RValue& is
-// "created" by doing *reinterpret_cast<RValue*>(this).  This has the appeal
-// of never creating a temporary RValue struct even with optimizations
-// disabled.  Also, by virtue of inheritance you can treat the RValue
-// reference as if it were the move-only type itself.  Unfortunately,
-// using the result of this reinterpret_cast<> is actually undefined behavior
-// due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer
-// will generate non-working code.
-//
-// In optimized builds, both implementations generate the same assembly so we
-// choose the one that adheres to the standard.
-//
-//
-// WHY HAVE typedef void MoveOnlyTypeForCPP03
-//
-// Callback<>/Bind() needs to understand movable-but-not-copyable semantics
-// to call .Pass() appropriately when it is expected to transfer the value.
-// The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check
-// easy and automatic in helper templates for Callback<>/Bind().
-// See IsMoveOnlyType template and its usage in base/callback_internal.h
-// for more details.
-//
-//
-// COMPARED TO C++11
-//
-// In C++11, you would implement this functionality using an r-value reference
-// and our .Pass() method would be replaced with a call to std::move().
-//
-// This emulation also has a deficiency where it uses up the single
-// user-defined conversion allowed by C++ during initialization.  This can
-// cause problems in some API edge cases.  For instance, in scoped_ptr, it is
-// impossible to make a function "void Foo(scoped_ptr<Parent> p)" accept a
-// value of type scoped_ptr<Child> even if you add a constructor to
-// scoped_ptr<> that would make it look like it should work.  C++11 does not
-// have this deficiency.
-//
-//
-// COMPARED TO Boost.Move
-//
-// Our implementation similar to Boost.Move, but we keep the RValue struct
-// private to the move-only type, and we don't use the reinterpret_cast<> hack.
-//
-// In Boost.Move, RValue is the boost::rv<> template.  This type can be used
-// when writing APIs like:
-//
-//   void MyFunc(boost::rv<Foo>& f)
-//
-// that can take advantage of rv<> to avoid extra copies of a type.  However you
-// would still be able to call this version of MyFunc with an l-value:
-//
-//   Foo f;
-//   MyFunc(f);  // Uh oh, we probably just destroyed |f| w/o calling Pass().
-//
-// unless someone is very careful to also declare a parallel override like:
-//
-//   void MyFunc(const Foo& f)
-//
-// that would catch the l-values first.  This was declared unsafe in C++11 and
-// a C++11 compiler will explicitly fail MyFunc(f).  Unfortunately, we cannot
-// ensure this in C++03.
-//
-// Since we have no need for writing such APIs yet, our implementation keeps
-// RValue private and uses a .Pass() method to do the conversion instead of
-// trying to write a version of "std::move()." Writing an API like std::move()
-// would require the RValue struct to be public.
-//
-//
-// CAVEATS
-//
-// If you include a move-only type as a field inside a class that does not
-// explicitly declare a copy constructor, the containing class's implicit
-// copy constructor will change from Containing(const Containing&) to
-// Containing(Containing&).  This can cause some unexpected errors.
-//
-//   http://llvm.org/bugs/show_bug.cgi?id=11528
-//
-// The workaround is to explicitly declare your copy constructor.
-//
-#define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type)       \
- private:                                                  \
-  struct rvalue_type {                                     \
-    explicit rvalue_type(type* object) : object(object) {} \
-    type* object;                                          \
-  };                                                       \
-  type(type&);                                             \
-  void operator=(type&);                                   \
-                                                           \
- public:                                                   \
-  operator rvalue_type() { return rvalue_type(this); }     \
-  type Pass() { return type(rvalue_type(this)); }          \
-  typedef void MoveOnlyTypeForCPP03;                       \
-                                                           \
- private:
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_MOVE_H_

include/base/cef_platform_thread.h

@@ -35,12 +35,7 @@
 #ifndef CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
 #define CEF_INCLUDE_BASE_PLATFORM_THREAD_H_
 
-#if defined(BASE_THREADING_PLATFORM_THREAD_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/threading/platform_thread.h"
 #else  // !USING_CHROMIUM_INCLUDES

include/base/cef_ptr_util.h

@@ -0,0 +1,58 @@
+// Copyright (c) 2021 Marshall A. Greenblatt. Portions copyright (c) 2015
+// 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 INCLUDE_BASE_CEF_PTR_UTIL_H_
+#define INCLUDE_BASE_CEF_PTR_UTIL_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/memory/ptr_util.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <memory>
+#include <utility>
+
+namespace base {
+
+// Helper to transfer ownership of a raw pointer to a std::unique_ptr<T>.
+// Note that std::unique_ptr<T> has very different semantics from
+// std::unique_ptr<T[]>: do not use this helper for array allocations.
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) {
+  return std::unique_ptr<T>(ptr);
+}
+
+}  // namespace base
+
+#endif  // INCLUDE_BASE_CEF_PTR_UTIL_H_

include/base/cef_ref_counted.h

@@ -33,12 +33,7 @@
 #define CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_
 #pragma once
 
-#if defined(BASE_MEMORY_REF_COUNTED_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/memory/ref_counted.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -46,15 +41,19 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include <cassert>
+#include <stddef.h>
+
+#include <utility>
 
 #include "include/base/cef_atomic_ref_count.h"
 #include "include/base/cef_build.h"
+#include "include/base/cef_compiler_specific.h"
 #include "include/base/cef_logging.h"
-#include "include/base/cef_macros.h"
+#include "include/base/cef_scoped_refptr.h"
+#include "include/base/cef_template_util.h"
+#include "include/base/cef_thread_checker.h"
 
 namespace base {
-
 namespace cef_subtle {
 
 class RefCountedBase {
@@ -63,15 +62,22 @@ class RefCountedBase {
   bool HasAtLeastOneRef() const { return ref_count_ >= 1; }
 
  protected:
-  RefCountedBase()
+  explicit RefCountedBase(StartRefCountFromZeroTag) {
-      : ref_count_(0)
 #if DCHECK_IS_ON()
-        ,
+    thread_checker_.DetachFromThread();
-        in_dtor_(false)
 #endif
-  {
   }
 
+  explicit RefCountedBase(StartRefCountFromOneTag) : ref_count_(1) {
+#if DCHECK_IS_ON()
+    needs_adopt_ref_ = true;
+    thread_checker_.DetachFromThread();
+#endif
+  }
+
+  RefCountedBase(const RefCountedBase&) = delete;
+  RefCountedBase& operator=(const RefCountedBase&) = delete;
+
   ~RefCountedBase() {
 #if DCHECK_IS_ON()
     DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
@@ -81,31 +87,89 @@ class RefCountedBase {
   void AddRef() const {
 #if DCHECK_IS_ON()
     DCHECK(!in_dtor_);
+    DCHECK(!needs_adopt_ref_)
+        << "This RefCounted object is created with non-zero reference count."
+        << " The first reference to such a object has to be made by AdoptRef or"
+        << " MakeRefCounted.";
+    if (ref_count_ >= 1) {
+      DCHECK(CalledOnValidThread());
+    }
 #endif
-    ++ref_count_;
+
+    AddRefImpl();
   }
 
   // Returns true if the object should self-delete.
   bool Release() const {
+    ReleaseImpl();
+
 #if DCHECK_IS_ON()
     DCHECK(!in_dtor_);
-#endif
+    if (ref_count_ == 0)
-    if (--ref_count_ == 0) {
-#if DCHECK_IS_ON()
       in_dtor_ = true;
+
+    if (ref_count_ >= 1)
+      DCHECK(CalledOnValidThread());
+    if (ref_count_ == 1)
+      thread_checker_.DetachFromThread();
 #endif
-      return true;
+
+    return ref_count_ == 0;
   }
-    return false;
+
+  // Returns true if it is safe to read or write the object, from a thread
+  // safety standpoint. Should be DCHECK'd from the methods of RefCounted
+  // classes if there is a danger of objects being shared across threads.
+  //
+  // This produces fewer false positives than adding a separate ThreadChecker
+  // into the subclass, because it automatically detaches from the thread when
+  // the reference count is 1 (and never fails if there is only one reference).
+  //
+  // This means unlike a separate ThreadChecker, it will permit a singly
+  // referenced object to be passed between threads (not holding a reference on
+  // the sending thread), but will trap if the sending thread holds onto a
+  // reference, or if the object is accessed from multiple threads
+  // simultaneously.
+  bool IsOnValidThread() const {
+#if DCHECK_IS_ON()
+    return ref_count_ <= 1 || CalledOnValidThread();
+#else
+    return true;
+#endif
   }
 
  private:
-  mutable int ref_count_;
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+
+  void Adopted() const {
 #if DCHECK_IS_ON()
-  mutable bool in_dtor_;
+    DCHECK(needs_adopt_ref_);
+    needs_adopt_ref_ = false;
+#endif
+  }
+
+#if defined(ARCH_CPU_64_BITS)
+  void AddRefImpl() const;
+  void ReleaseImpl() const;
+#else
+  void AddRefImpl() const { ++ref_count_; }
+  void ReleaseImpl() const { --ref_count_; }
 #endif
 
-  DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
+#if DCHECK_IS_ON()
+  bool CalledOnValidThread() const;
+#endif
+
+  mutable uint32_t ref_count_ = 0;
+  static_assert(std::is_unsigned<decltype(ref_count_)>::value,
+                "ref_count_ must be an unsigned type.");
+
+#if DCHECK_IS_ON()
+  mutable bool needs_adopt_ref_ = false;
+  mutable bool in_dtor_ = false;
+  mutable ThreadChecker thread_checker_;
+#endif
 };
 
 class RefCountedThreadSafeBase {
@@ -114,28 +178,121 @@ class RefCountedThreadSafeBase {
   bool HasAtLeastOneRef() const;
 
  protected:
-  RefCountedThreadSafeBase();
+  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromZeroTag) {}
-  ~RefCountedThreadSafeBase();
+  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromOneTag)
-
+      : ref_count_(1) {
-  void AddRef() const;
-
-  // Returns true if the object should self-delete.
-  bool Release() const;
-
- private:
-  mutable AtomicRefCount ref_count_;
 #if DCHECK_IS_ON()
-  mutable bool in_dtor_;
+    needs_adopt_ref_ = true;
+#endif
+  }
+
+  RefCountedThreadSafeBase(const RefCountedThreadSafeBase&) = delete;
+  RefCountedThreadSafeBase& operator=(const RefCountedThreadSafeBase&) = delete;
+
+#if DCHECK_IS_ON()
+  ~RefCountedThreadSafeBase();
+#else
+  ~RefCountedThreadSafeBase() = default;
 #endif
 
-  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
+// Release and AddRef are suitable for inlining on X86 because they generate
+// very small code threads. On other platforms (ARM), it causes a size
+// regression and is probably not worth it.
+#if defined(ARCH_CPU_X86_FAMILY)
+  // Returns true if the object should self-delete.
+  bool Release() const { return ReleaseImpl(); }
+  void AddRef() const { AddRefImpl(); }
+  void AddRefWithCheck() const { AddRefWithCheckImpl(); }
+#else
+  // Returns true if the object should self-delete.
+  bool Release() const;
+  void AddRef() const;
+  void AddRefWithCheck() const;
+#endif
+
+ private:
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+
+  void Adopted() const {
+#if DCHECK_IS_ON()
+    DCHECK(needs_adopt_ref_);
+    needs_adopt_ref_ = false;
+#endif
+  }
+
+  ALWAYS_INLINE void AddRefImpl() const {
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!needs_adopt_ref_)
+        << "This RefCounted object is created with non-zero reference count."
+        << " The first reference to such a object has to be made by AdoptRef or"
+        << " MakeRefCounted.";
+#endif
+    ref_count_.Increment();
+  }
+
+  ALWAYS_INLINE void AddRefWithCheckImpl() const {
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!needs_adopt_ref_)
+        << "This RefCounted object is created with non-zero reference count."
+        << " The first reference to such a object has to be made by AdoptRef or"
+        << " MakeRefCounted.";
+#endif
+    CHECK(ref_count_.Increment() > 0);
+  }
+
+  ALWAYS_INLINE bool ReleaseImpl() const {
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!ref_count_.IsZero());
+#endif
+    if (!ref_count_.Decrement()) {
+#if DCHECK_IS_ON()
+      in_dtor_ = true;
+#endif
+      return true;
+    }
+    return false;
+  }
+
+  mutable AtomicRefCount ref_count_{0};
+#if DCHECK_IS_ON()
+  mutable bool needs_adopt_ref_ = false;
+  mutable bool in_dtor_ = false;
+#endif
+};
+
+// ScopedAllowCrossThreadRefCountAccess disables the check documented on
+// RefCounted below for rare pre-existing use cases where thread-safety was
+// guaranteed through other means (e.g. explicit sequencing of calls across
+// execution threads when bouncing between threads in order). New callers
+// should refrain from using this (callsites handling thread-safety through
+// locks should use RefCountedThreadSafe per the overhead of its atomics being
+// negligible compared to locks anyways and callsites doing explicit sequencing
+// should properly std::move() the ref to avoid hitting this check).
+// TODO(tzik): Cleanup existing use cases and remove
+// ScopedAllowCrossThreadRefCountAccess.
+class ScopedAllowCrossThreadRefCountAccess final {
+ public:
+#if DCHECK_IS_ON()
+  ScopedAllowCrossThreadRefCountAccess();
+  ~ScopedAllowCrossThreadRefCountAccess();
+#else
+  ScopedAllowCrossThreadRefCountAccess() {}
+  ~ScopedAllowCrossThreadRefCountAccess() {}
+#endif
 };
 
 }  // namespace cef_subtle
 
+using ScopedAllowCrossThreadRefCountAccess =
+    cef_subtle::ScopedAllowCrossThreadRefCountAccess;
+
 //
 // A base class for reference counted classes.  Otherwise, known as a cheap
-// knock-off of WebKit's RefCounted<T> class.  To use this guy just extend your
+// knock-off of WebKit's RefCounted<T> class.  To use this, just extend your
 // class from it like so:
 //
 //   class MyFoo : public base::RefCounted<MyFoo> {
@@ -145,26 +302,87 @@ class RefCountedThreadSafeBase {
 //     ~MyFoo();
 //   };
 //
-// You should always make your destructor private, to avoid any code deleting
+// Usage Notes:
-// the object accidently while there are references to it.
+// 1. You should always make your destructor non-public, to avoid any code
-template <class T>
+// deleting the object accidentally while there are references to it.
+// 2. You should always make the ref-counted base class a friend of your class,
+// so that it can access the destructor.
+//
+// The ref count manipulation to RefCounted is NOT thread safe and has DCHECKs
+// to trap unsafe cross thread usage. A subclass instance of RefCounted can be
+// passed to another execution thread only when its ref count is 1. If the ref
+// count is more than 1, the RefCounted class verifies the ref updates are made
+// on the same execution thread as the previous ones. The subclass can also
+// manually call IsOnValidThread to trap other non-thread-safe accesses; see
+// the documentation for that method.
+//
+//
+// The reference count starts from zero by default, and we intended to migrate
+// to start-from-one ref count. Put REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() to
+// the ref counted class to opt-in.
+//
+// If an object has start-from-one ref count, the first scoped_refptr need to be
+// created by base::AdoptRef() or base::MakeRefCounted(). We can use
+// base::MakeRefCounted() to create create both type of ref counted object.
+//
+// The motivations to use start-from-one ref count are:
+//  - Start-from-one ref count doesn't need the ref count increment for the
+//    first reference.
+//  - It can detect an invalid object acquisition for a being-deleted object
+//    that has zero ref count. That tends to happen on custom deleter that
+//    delays the deletion.
+//    TODO(tzik): Implement invalid acquisition detection.
+//  - Behavior parity to Blink's WTF::RefCounted, whose count starts from one.
+//    And start-from-one ref count is a step to merge WTF::RefCounted into
+//    base::RefCounted.
+//
+#define REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE()                 \
+  static constexpr ::base::cef_subtle::StartRefCountFromOneTag \
+      kRefCountPreference = ::base::cef_subtle::kStartRefCountFromOneTag
+
+template <class T, typename Traits>
+class RefCounted;
+
+template <typename T>
+struct DefaultRefCountedTraits {
+  static void Destruct(const T* x) {
+    RefCounted<T, DefaultRefCountedTraits>::DeleteInternal(x);
+  }
+};
+
+template <class T, typename Traits = DefaultRefCountedTraits<T>>
 class RefCounted : public cef_subtle::RefCountedBase {
  public:
-  RefCounted() {}
+  static constexpr cef_subtle::StartRefCountFromZeroTag kRefCountPreference =
+      cef_subtle::kStartRefCountFromZeroTag;
+
+  RefCounted() : cef_subtle::RefCountedBase(T::kRefCountPreference) {}
+
+  RefCounted(const RefCounted&) = delete;
+  RefCounted& operator=(const RefCounted&) = delete;
 
   void AddRef() const { cef_subtle::RefCountedBase::AddRef(); }
 
   void Release() const {
     if (cef_subtle::RefCountedBase::Release()) {
-      delete static_cast<const T*>(this);
+      // Prune the code paths which the static analyzer may take to simulate
+      // object destruction. Use-after-free errors aren't possible given the
+      // lifetime guarantees of the refcounting system.
+      ANALYZER_SKIP_THIS_PATH();
+
+      Traits::Destruct(static_cast<const T*>(this));
     }
   }
 
  protected:
-  ~RefCounted() {}
+  ~RefCounted() = default;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(RefCounted<T>);
+  friend struct DefaultRefCountedTraits<T>;
+  template <typename U>
+  static void DeleteInternal(const U* x) {
+    delete x;
+  }
 };
 
 // Forward declaration.
@@ -196,27 +414,47 @@ struct DefaultRefCountedThreadSafeTraits {
 //    private:
 //     friend class base::RefCountedThreadSafe<MyFoo>;
 //     ~MyFoo();
+//
+// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
+// too. See the comment above the RefCounted definition for details.
 template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T>>
 class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
  public:
-  RefCountedThreadSafe() {}
+  static constexpr cef_subtle::StartRefCountFromZeroTag kRefCountPreference =
+      cef_subtle::kStartRefCountFromZeroTag;
 
-  void AddRef() const { cef_subtle::RefCountedThreadSafeBase::AddRef(); }
+  explicit RefCountedThreadSafe()
+      : cef_subtle::RefCountedThreadSafeBase(T::kRefCountPreference) {}
+
+  RefCountedThreadSafe(const RefCountedThreadSafe&) = delete;
+  RefCountedThreadSafe& operator=(const RefCountedThreadSafe&) = delete;
+
+  void AddRef() const { AddRefImpl(T::kRefCountPreference); }
 
   void Release() const {
     if (cef_subtle::RefCountedThreadSafeBase::Release()) {
+      ANALYZER_SKIP_THIS_PATH();
       Traits::Destruct(static_cast<const T*>(this));
     }
   }
 
  protected:
-  ~RefCountedThreadSafe() {}
+  ~RefCountedThreadSafe() = default;
 
  private:
   friend struct DefaultRefCountedThreadSafeTraits<T>;
-  static void DeleteInternal(const T* x) { delete x; }
+  template <typename U>
+  static void DeleteInternal(const U* x) {
+    delete x;
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
+  void AddRefImpl(cef_subtle::StartRefCountFromZeroTag) const {
+    cef_subtle::RefCountedThreadSafeBase::AddRef();
+  }
+
+  void AddRefImpl(cef_subtle::StartRefCountFromOneTag) const {
+    cef_subtle::RefCountedThreadSafeBase::AddRefWithCheck();
+  }
 };
 
 //
@@ -229,142 +467,30 @@ class RefCountedData
  public:
   RefCountedData() : data() {}
   RefCountedData(const T& in_value) : data(in_value) {}
+  RefCountedData(T&& in_value) : data(std::move(in_value)) {}
+  template <typename... Args>
+  explicit RefCountedData(in_place_t, Args&&... args)
+      : data(std::forward<Args>(args)...) {}
 
   T data;
 
  private:
   friend class base::RefCountedThreadSafe<base::RefCountedData<T>>;
-  ~RefCountedData() {}
+  ~RefCountedData() = default;
 };
 
+template <typename T>
+bool operator==(const RefCountedData<T>& lhs, const RefCountedData<T>& rhs) {
+  return lhs.data == rhs.data;
+}
+
+template <typename T>
+bool operator!=(const RefCountedData<T>& lhs, const RefCountedData<T>& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace base
 
-//
-// A smart pointer class for reference counted objects.  Use this class instead
-// of calling AddRef and Release manually on a reference counted object to
-// avoid common memory leaks caused by forgetting to Release an object
-// reference.  Sample usage:
-//
-//   class MyFoo : public RefCounted<MyFoo> {
-//    ...
-//   };
-//
-//   void some_function() {
-//     scoped_refptr<MyFoo> foo = new MyFoo();
-//     foo->Method(param);
-//     // |foo| is released when this function returns
-//   }
-//
-//   void some_other_function() {
-//     scoped_refptr<MyFoo> foo = new MyFoo();
-//     ...
-//     foo = NULL;  // explicitly releases |foo|
-//     ...
-//     if (foo)
-//       foo->Method(param);
-//   }
-//
-// The above examples show how scoped_refptr<T> acts like a pointer to T.
-// Given two scoped_refptr<T> classes, it is also possible to exchange
-// references between the two objects, like so:
-//
-//   {
-//     scoped_refptr<MyFoo> a = new MyFoo();
-//     scoped_refptr<MyFoo> b;
-//
-//     b.swap(a);
-//     // now, |b| references the MyFoo object, and |a| references NULL.
-//   }
-//
-// To make both |a| and |b| in the above example reference the same MyFoo
-// object, simply use the assignment operator:
-//
-//   {
-//     scoped_refptr<MyFoo> a = new MyFoo();
-//     scoped_refptr<MyFoo> b;
-//
-//     b = a;
-//     // now, |a| and |b| each own a reference to the same MyFoo object.
-//   }
-//
-template <class T>
-class scoped_refptr {
- public:
-  typedef T element_type;
-
-  scoped_refptr() : ptr_(NULL) {}
-
-  scoped_refptr(T* p) : ptr_(p) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  template <typename U>
-  scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  ~scoped_refptr() {
-    if (ptr_)
-      ptr_->Release();
-  }
-
-  T* get() const { return ptr_; }
-
-  // Allow scoped_refptr<C> to be used in boolean expression
-  // and comparison operations.
-  operator T*() const { return ptr_; }
-
-  T* operator->() const {
-    assert(ptr_ != NULL);
-    return ptr_;
-  }
-
-  scoped_refptr<T>& operator=(T* p) {
-    // AddRef first so that self assignment should work
-    if (p)
-      p->AddRef();
-    T* old_ptr = ptr_;
-    ptr_ = p;
-    if (old_ptr)
-      old_ptr->Release();
-    return *this;
-  }
-
-  scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
-    return *this = r.ptr_;
-  }
-
-  template <typename U>
-  scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
-    return *this = r.get();
-  }
-
-  void swap(T** pp) {
-    T* p = ptr_;
-    ptr_ = *pp;
-    *pp = p;
-  }
-
-  void swap(scoped_refptr<T>& r) { swap(&r.ptr_); }
-
- protected:
-  T* ptr_;
-};
-
-// Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
-// having to retype all the template arguments
-template <typename T>
-scoped_refptr<T> make_scoped_refptr(T* t) {
-  return scoped_refptr<T>(t);
-}
-
 #endif  // !USING_CHROMIUM_INCLUDES
 
 #endif  // CEF_INCLUDE_BASE_CEF_REF_COUNTED_H_

include/base/cef_scoped_ptr.h

@@ -1,625 +0,0 @@
-// Copyright (c) 2014 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.
-
-// Scopers help you manage ownership of a pointer, helping you easily manage a
-// pointer within a scope, and automatically destroying the pointer at the end
-// of a scope.  There are two main classes you will use, which correspond to the
-// operators new/delete and new[]/delete[].
-//
-// Example usage (scoped_ptr<T>):
-//   {
-//     scoped_ptr<Foo> foo(new Foo("wee"));
-//   }  // foo goes out of scope, releasing the pointer with it.
-//
-//   {
-//     scoped_ptr<Foo> foo;          // No pointer managed.
-//     foo.reset(new Foo("wee"));    // Now a pointer is managed.
-//     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
-//     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
-//     foo->Method();                // Foo::Method() called.
-//     foo.get()->Method();          // Foo::Method() called.
-//     SomeFunc(foo.release());      // SomeFunc takes ownership, foo no longer
-//                                   // manages a pointer.
-//     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
-//     foo.reset();                  // Foo("wee4") destroyed, foo no longer
-//                                   // manages a pointer.
-//   }  // foo wasn't managing a pointer, so nothing was destroyed.
-//
-// Example usage (scoped_ptr<T[]>):
-//   {
-//     scoped_ptr<Foo[]> foo(new Foo[100]);
-//     foo.get()->Method();  // Foo::Method on the 0th element.
-//     foo[10].Method();     // Foo::Method on the 10th element.
-//   }
-//
-// These scopers also implement part of the functionality of C++11 unique_ptr
-// in that they are "movable but not copyable."  You can use the scopers in
-// the parameter and return types of functions to signify ownership transfer
-// in to and out of a function.  When calling a function that has a scoper
-// as the argument type, it must be called with the result of an analogous
-// scoper's Pass() function or another function that generates a temporary;
-// passing by copy will NOT work.  Here is an example using scoped_ptr:
-//
-//   void TakesOwnership(scoped_ptr<Foo> arg) {
-//     // Do something with arg
-//   }
-//   scoped_ptr<Foo> CreateFoo() {
-//     // No need for calling Pass() because we are constructing a temporary
-//     // for the return value.
-//     return scoped_ptr<Foo>(new Foo("new"));
-//   }
-//   scoped_ptr<Foo> PassThru(scoped_ptr<Foo> arg) {
-//     return arg.Pass();
-//   }
-//
-//   {
-//     scoped_ptr<Foo> ptr(new Foo("yay"));  // ptr manages Foo("yay").
-//     TakesOwnership(ptr.Pass());           // ptr no longer owns Foo("yay").
-//     scoped_ptr<Foo> ptr2 = CreateFoo();   // ptr2 owns the return Foo.
-//     scoped_ptr<Foo> ptr3 =                // ptr3 now owns what was in ptr2.
-//         PassThru(ptr2.Pass());            // ptr2 is correspondingly NULL.
-//   }
-//
-// Notice that if you do not call Pass() when returning from PassThru(), or
-// when invoking TakesOwnership(), the code will not compile because scopers
-// are not copyable; they only implement move semantics which require calling
-// the Pass() function to signify a destructive transfer of state. CreateFoo()
-// is different though because we are constructing a temporary on the return
-// line and thus can avoid needing to call Pass().
-//
-// Pass() properly handles upcast in initialization, i.e. you can use a
-// scoped_ptr<Child> to initialize a scoped_ptr<Parent>:
-//
-//   scoped_ptr<Foo> foo(new Foo());
-//   scoped_ptr<FooParent> parent(foo.Pass());
-//
-// PassAs<>() should be used to upcast return value in return statement:
-//
-//   scoped_ptr<Foo> CreateFoo() {
-//     scoped_ptr<FooChild> result(new FooChild());
-//     return result.PassAs<Foo>();
-//   }
-//
-// Note that PassAs<>() is implemented only for scoped_ptr<T>, but not for
-// scoped_ptr<T[]>. This is because casting array pointers may not be safe.
-
-#ifndef CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
-#define CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_
-#pragma once
-
-#if defined(BASE_MEMORY_SCOPED_PTR_H_)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
-// Do nothing when building CEF.
-#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.
-
-// This is an implementation designed to match the anticipated future TR2
-// implementation of the scoped_ptr class.
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include <algorithm>  // For std::swap().
-
-#include "include/base/cef_basictypes.h"
-#include "include/base/cef_build.h"
-#include "include/base/cef_macros.h"
-#include "include/base/cef_move.h"
-#include "include/base/cef_template_util.h"
-
-namespace base {
-
-namespace subtle {
-class RefCountedBase;
-class RefCountedThreadSafeBase;
-}  // namespace subtle
-
-// Function object which deletes its parameter, which must be a pointer.
-// If C is an array type, invokes 'delete[]' on the parameter; otherwise,
-// invokes 'delete'. The default deleter for scoped_ptr<T>.
-template <class T>
-struct DefaultDeleter {
-  DefaultDeleter() {}
-  template <typename U>
-  DefaultDeleter(const DefaultDeleter<U>& other) {
-    // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
-    // if U* is implicitly convertible to T* and U is not an array type.
-    //
-    // Correct implementation should use SFINAE to disable this
-    // constructor. However, since there are no other 1-argument constructors,
-    // using a COMPILE_ASSERT() based on is_convertible<> and requiring
-    // complete types is simpler and will cause compile failures for equivalent
-    // misuses.
-    //
-    // Note, the is_convertible<U*, T*> check also ensures that U is not an
-    // array. T is guaranteed to be a non-array, so any U* where U is an array
-    // cannot convert to T*.
-    enum { T_must_be_complete = sizeof(T) };
-    enum { U_must_be_complete = sizeof(U) };
-    COMPILE_ASSERT((base::is_convertible<U*, T*>::value),
-                   U_ptr_must_implicitly_convert_to_T_ptr);
-  }
-  inline void operator()(T* ptr) const {
-    enum { type_must_be_complete = sizeof(T) };
-    delete ptr;
-  }
-};
-
-// Specialization of DefaultDeleter for array types.
-template <class T>
-struct DefaultDeleter<T[]> {
-  inline void operator()(T* ptr) const {
-    enum { type_must_be_complete = sizeof(T) };
-    delete[] ptr;
-  }
-
- private:
-  // Disable this operator for any U != T because it is undefined to execute
-  // an array delete when the static type of the array mismatches the dynamic
-  // type.
-  //
-  // References:
-  //   C++98 [expr.delete]p3
-  //   http://cplusplus.github.com/LWG/lwg-defects.html#938
-  template <typename U>
-  void operator()(U* array) const;
-};
-
-template <class T, int n>
-struct DefaultDeleter<T[n]> {
-  // Never allow someone to declare something like scoped_ptr<int[10]>.
-  COMPILE_ASSERT(sizeof(T) == -1, do_not_use_array_with_size_as_type);
-};
-
-// Function object which invokes 'free' on its parameter, which must be
-// a pointer. Can be used to store malloc-allocated pointers in scoped_ptr:
-//
-// scoped_ptr<int, base::FreeDeleter> foo_ptr(
-//     static_cast<int*>(malloc(sizeof(int))));
-struct FreeDeleter {
-  inline void operator()(void* ptr) const { free(ptr); }
-};
-
-namespace cef_internal {
-
-template <typename T>
-struct IsNotRefCounted {
-  enum {
-    value =
-        !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
-        !base::is_convertible<T*,
-                              base::subtle::RefCountedThreadSafeBase*>::value
-  };
-};
-
-// Minimal implementation of the core logic of scoped_ptr, suitable for
-// reuse in both scoped_ptr and its specializations.
-template <class T, class D>
-class scoped_ptr_impl {
- public:
-  explicit scoped_ptr_impl(T* p) : data_(p) {}
-
-  // Initializer for deleters that have data parameters.
-  scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
-
-  // Templated constructor that destructively takes the value from another
-  // scoped_ptr_impl.
-  template <typename U, typename V>
-  scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
-      : data_(other->release(), other->get_deleter()) {
-    // We do not support move-only deleters.  We could modify our move
-    // emulation to have base::subtle::move() and base::subtle::forward()
-    // functions that are imperfect emulations of their C++11 equivalents,
-    // but until there's a requirement, just assume deleters are copyable.
-  }
-
-  template <typename U, typename V>
-  void TakeState(scoped_ptr_impl<U, V>* other) {
-    // See comment in templated constructor above regarding lack of support
-    // for move-only deleters.
-    reset(other->release());
-    get_deleter() = other->get_deleter();
-  }
-
-  ~scoped_ptr_impl() {
-    if (data_.ptr != NULL) {
-      // Not using get_deleter() saves one function call in non-optimized
-      // builds.
-      static_cast<D&>(data_)(data_.ptr);
-    }
-  }
-
-  void reset(T* p) {
-    // This is a self-reset, which is no longer allowed: http://crbug.com/162971
-    if (p != NULL && p == data_.ptr)
-      abort();
-
-    // Note that running data_.ptr = p can lead to undefined behavior if
-    // get_deleter()(get()) deletes this. In order to prevent this, reset()
-    // should update the stored pointer before deleting its old value.
-    //
-    // However, changing reset() to use that behavior may cause current code to
-    // break in unexpected ways. If the destruction of the owned object
-    // dereferences the scoped_ptr when it is destroyed by a call to reset(),
-    // then it will incorrectly dispatch calls to |p| rather than the original
-    // value of |data_.ptr|.
-    //
-    // During the transition period, set the stored pointer to NULL while
-    // deleting the object. Eventually, this safety check will be removed to
-    // prevent the scenario initially described from occuring and
-    // http://crbug.com/176091 can be closed.
-    T* old = data_.ptr;
-    data_.ptr = NULL;
-    if (old != NULL)
-      static_cast<D&>(data_)(old);
-    data_.ptr = p;
-  }
-
-  T* get() const { return data_.ptr; }
-
-  D& get_deleter() { return data_; }
-  const D& get_deleter() const { return data_; }
-
-  void swap(scoped_ptr_impl& p2) {
-    // Standard swap idiom: 'using std::swap' ensures that std::swap is
-    // present in the overload set, but we call swap unqualified so that
-    // any more-specific overloads can be used, if available.
-    using std::swap;
-    swap(static_cast<D&>(data_), static_cast<D&>(p2.data_));
-    swap(data_.ptr, p2.data_.ptr);
-  }
-
-  T* release() {
-    T* old_ptr = data_.ptr;
-    data_.ptr = NULL;
-    return old_ptr;
-  }
-
- private:
-  // Needed to allow type-converting constructor.
-  template <typename U, typename V>
-  friend class scoped_ptr_impl;
-
-  // Use the empty base class optimization to allow us to have a D
-  // member, while avoiding any space overhead for it when D is an
-  // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
-  // discussion of this technique.
-  struct Data : public D {
-    explicit Data(T* ptr_in) : ptr(ptr_in) {}
-    Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {}
-    T* ptr;
-  };
-
-  Data data_;
-
-  DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
-};
-
-}  // namespace cef_internal
-
-}  // namespace base
-
-// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
-// automatically deletes the pointer it holds (if any).
-// That is, scoped_ptr<T> owns the T object that it points to.
-// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
-// Also like T*, scoped_ptr<T> is thread-compatible, and once you
-// dereference it, you get the thread safety guarantees of T.
-//
-// The size of scoped_ptr is small. On most compilers, when using the
-// DefaultDeleter, sizeof(scoped_ptr<T>) == sizeof(T*). Custom deleters will
-// increase the size proportional to whatever state they need to have. See
-// comments inside scoped_ptr_impl<> for details.
-//
-// Current implementation targets having a strict subset of  C++11's
-// unique_ptr<> features. Known deficiencies include not supporting move-only
-// deleteres, function pointers as deleters, and deleters with reference
-// types.
-template <class T, class D = base::DefaultDeleter<T>>
-class scoped_ptr {
-  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
-
-  COMPILE_ASSERT(base::cef_internal::IsNotRefCounted<T>::value,
-                 T_is_refcounted_type_and_needs_scoped_refptr);
-
- public:
-  // The element and deleter types.
-  typedef T element_type;
-  typedef D deleter_type;
-
-  // Constructor.  Defaults to initializing with NULL.
-  scoped_ptr() : impl_(NULL) {}
-
-  // Constructor.  Takes ownership of p.
-  explicit scoped_ptr(element_type* p) : impl_(p) {}
-
-  // Constructor.  Allows initialization of a stateful deleter.
-  scoped_ptr(element_type* p, const D& d) : impl_(p, d) {}
-
-  // Constructor.  Allows construction from a scoped_ptr rvalue for a
-  // convertible type and deleter.
-  //
-  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct
-  // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
-  // has different post-conditions if D is a reference type. Since this
-  // implementation does not support deleters with reference type,
-  // we do not need a separate move constructor allowing us to avoid one
-  // use of SFINAE. You only need to care about this if you modify the
-  // implementation of scoped_ptr.
-  template <typename U, typename V>
-  scoped_ptr(scoped_ptr<U, V> other) : impl_(&other.impl_) {
-    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
-  }
-
-  // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
-
-  // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
-  // type and deleter.
-  //
-  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
-  // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
-  // form has different requirements on for move-only Deleters. Since this
-  // implementation does not support move-only Deleters, we do not need a
-  // separate move assignment operator allowing us to avoid one use of SFINAE.
-  // You only need to care about this if you modify the implementation of
-  // scoped_ptr.
-  template <typename U, typename V>
-  scoped_ptr& operator=(scoped_ptr<U, V> rhs) {
-    COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
-    impl_.TakeState(&rhs.impl_);
-    return *this;
-  }
-
-  // Reset.  Deletes the currently owned object, if any.
-  // Then takes ownership of a new object, if given.
-  void reset(element_type* p = NULL) { impl_.reset(p); }
-
-  // Accessors to get the owned object.
-  // operator* and operator-> will assert() if there is no current object.
-  element_type& operator*() const {
-    assert(impl_.get() != NULL);
-    return *impl_.get();
-  }
-  element_type* operator->() const {
-    assert(impl_.get() != NULL);
-    return impl_.get();
-  }
-  element_type* get() const { return impl_.get(); }
-
-  // Access to the deleter.
-  deleter_type& get_deleter() { return impl_.get_deleter(); }
-  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
-
-  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
-  // implicitly convertible to a real bool (which is dangerous).
-  //
-  // Note that this trick is only safe when the == and != operators
-  // are declared explicitly, as otherwise "scoped_ptr1 ==
-  // scoped_ptr2" will compile but do the wrong thing (i.e., convert
-  // to Testable and then do the comparison).
- private:
-  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
-      scoped_ptr::*Testable;
-
- public:
-  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
-
-  // Comparison operators.
-  // These return whether two scoped_ptr refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(const element_type* p) const { return impl_.get() == p; }
-  bool operator!=(const element_type* p) const { return impl_.get() != p; }
-
-  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
-
-  // Release a pointer.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
-
-  // C++98 doesn't support functions templates with default parameters which
-  // makes it hard to write a PassAs() that understands converting the deleter
-  // while preserving simple calling semantics.
-  //
-  // Until there is a use case for PassAs() with custom deleters, just ignore
-  // the custom deleter.
-  template <typename PassAsType>
-  scoped_ptr<PassAsType> PassAs() {
-    return scoped_ptr<PassAsType>(Pass());
-  }
-
- private:
-  // Needed to reach into |impl_| in the constructor.
-  template <typename U, typename V>
-  friend class scoped_ptr;
-  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
-
-  // Forbidden for API compatibility with std::unique_ptr.
-  explicit scoped_ptr(int disallow_construction_from_null);
-
-  // Forbid comparison of scoped_ptr types.  If U != T, it totally
-  // doesn't make sense, and if U == T, it still doesn't make sense
-  // because you should never have the same object owned by two different
-  // scoped_ptrs.
-  template <class U>
-  bool operator==(scoped_ptr<U> const& p2) const;
-  template <class U>
-  bool operator!=(scoped_ptr<U> const& p2) const;
-};
-
-template <class T, class D>
-class scoped_ptr<T[], D> {
-  MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
-
- public:
-  // The element and deleter types.
-  typedef T element_type;
-  typedef D deleter_type;
-
-  // Constructor.  Defaults to initializing with NULL.
-  scoped_ptr() : impl_(NULL) {}
-
-  // Constructor. Stores the given array. Note that the argument's type
-  // must exactly match T*. In particular:
-  // - it cannot be a pointer to a type derived from T, because it is
-  //   inherently unsafe in the general case to access an array through a
-  //   pointer whose dynamic type does not match its static type (eg., if
-  //   T and the derived types had different sizes access would be
-  //   incorrectly calculated). Deletion is also always undefined
-  //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
-  // - it cannot be NULL, because NULL is an integral expression, not a
-  //   pointer to T. Use the no-argument version instead of explicitly
-  //   passing NULL.
-  // - it cannot be const-qualified differently from T per unique_ptr spec
-  //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
-  //   to work around this may use implicit_cast<const T*>().
-  //   However, because of the first bullet in this comment, users MUST
-  //   NOT use implicit_cast<Base*>() to upcast the static type of the array.
-  explicit scoped_ptr(element_type* array) : impl_(array) {}
-
-  // Constructor.  Move constructor for C++03 move emulation of this type.
-  scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
-
-  // operator=.  Move operator= for C++03 move emulation of this type.
-  scoped_ptr& operator=(RValue rhs) {
-    impl_.TakeState(&rhs.object->impl_);
-    return *this;
-  }
-
-  // Reset.  Deletes the currently owned array, if any.
-  // Then takes ownership of a new object, if given.
-  void reset(element_type* array = NULL) { impl_.reset(array); }
-
-  // Accessors to get the owned array.
-  element_type& operator[](size_t i) const {
-    assert(impl_.get() != NULL);
-    return impl_.get()[i];
-  }
-  element_type* get() const { return impl_.get(); }
-
-  // Access to the deleter.
-  deleter_type& get_deleter() { return impl_.get_deleter(); }
-  const deleter_type& get_deleter() const { return impl_.get_deleter(); }
-
-  // Allow scoped_ptr<element_type> to be used in boolean expressions, but not
-  // implicitly convertible to a real bool (which is dangerous).
- private:
-  typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
-      scoped_ptr::*Testable;
-
- public:
-  operator Testable() const { return impl_.get() ? &scoped_ptr::impl_ : NULL; }
-
-  // Comparison operators.
-  // These return whether two scoped_ptr refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(element_type* array) const { return impl_.get() == array; }
-  bool operator!=(element_type* array) const { return impl_.get() != array; }
-
-  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
-
-  // Release a pointer.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
-
- private:
-  // Force element_type to be a complete type.
-  enum { type_must_be_complete = sizeof(element_type) };
-
-  // Actually hold the data.
-  base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
-
-  // Disable initialization from any type other than element_type*, by
-  // providing a constructor that matches such an initialization, but is
-  // private and has no definition. This is disabled because it is not safe to
-  // call delete[] on an array whose static type does not match its dynamic
-  // type.
-  template <typename U>
-  explicit scoped_ptr(U* array);
-  explicit scoped_ptr(int disallow_construction_from_null);
-
-  // Disable reset() from any type other than element_type*, for the same
-  // reasons as the constructor above.
-  template <typename U>
-  void reset(U* array);
-  void reset(int disallow_reset_from_null);
-
-  // Forbid comparison of scoped_ptr types.  If U != T, it totally
-  // doesn't make sense, and if U == T, it still doesn't make sense
-  // because you should never have the same object owned by two different
-  // scoped_ptrs.
-  template <class U>
-  bool operator==(scoped_ptr<U> const& p2) const;
-  template <class U>
-  bool operator!=(scoped_ptr<U> const& p2) const;
-};
-
-// Free functions
-template <class T, class D>
-void swap(scoped_ptr<T, D>& p1, scoped_ptr<T, D>& p2) {
-  p1.swap(p2);
-}
-
-template <class T, class D>
-bool operator==(T* p1, const scoped_ptr<T, D>& p2) {
-  return p1 == p2.get();
-}
-
-template <class T, class D>
-bool operator!=(T* p1, const scoped_ptr<T, D>& p2) {
-  return p1 != p2.get();
-}
-
-// A function to convert T* into scoped_ptr<T>
-// Doing e.g. make_scoped_ptr(new FooBarBaz<type>(arg)) is a shorter notation
-// for scoped_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
-template <typename T>
-scoped_ptr<T> make_scoped_ptr(T* ptr) {
-  return scoped_ptr<T>(ptr);
-}
-
-#endif  // !USING_CHROMIUM_INCLUDES
-
-#endif  // CEF_INCLUDE_BASE_CEF_MEMORY_SCOPED_PTR_H_

include/base/cef_scoped_refptr.h

@@ -0,0 +1,411 @@
+// Copyright (c) 2017 Marshall A. Greenblatt. Portions copyright (c) 2011
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_SCOPED_REFPTR_H_
+#define CEF_INCLUDE_BASE_CEF_SCOPED_REFPTR_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/memory/scoped_refptr.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+
+#include <stddef.h>
+
+#include <iosfwd>
+#include <type_traits>
+#include <utility>
+
+#include "include/base/cef_compiler_specific.h"
+#include "include/base/cef_logging.h"
+
+template <class T>
+class scoped_refptr;
+
+namespace base {
+
+template <class, typename>
+class RefCounted;
+template <class, typename>
+class RefCountedThreadSafe;
+class SequencedTaskRunner;
+class WrappedPromise;
+
+template <typename T>
+scoped_refptr<T> AdoptRef(T* t);
+
+namespace internal {
+
+class BasePromise;
+
+}  // namespace internal
+
+namespace cef_subtle {
+
+enum AdoptRefTag { kAdoptRefTag };
+enum StartRefCountFromZeroTag { kStartRefCountFromZeroTag };
+enum StartRefCountFromOneTag { kStartRefCountFromOneTag };
+
+template <typename T, typename U, typename V>
+constexpr bool IsRefCountPreferenceOverridden(const T*,
+                                              const RefCounted<U, V>*) {
+  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
+                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
+}
+
+template <typename T, typename U, typename V>
+constexpr bool IsRefCountPreferenceOverridden(
+    const T*,
+    const RefCountedThreadSafe<U, V>*) {
+  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
+                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
+}
+
+constexpr bool IsRefCountPreferenceOverridden(...) {
+  return false;
+}
+
+}  // namespace cef_subtle
+
+// Creates a scoped_refptr from a raw pointer without incrementing the reference
+// count. Use this only for a newly created object whose reference count starts
+// from 1 instead of 0.
+template <typename T>
+scoped_refptr<T> AdoptRef(T* obj) {
+  using Tag = std::decay_t<decltype(T::kRefCountPreference)>;
+  static_assert(std::is_same<cef_subtle::StartRefCountFromOneTag, Tag>::value,
+                "Use AdoptRef only if the reference count starts from one.");
+
+  DCHECK(obj);
+  DCHECK(obj->HasOneRef());
+  obj->Adopted();
+  return scoped_refptr<T>(obj, cef_subtle::kAdoptRefTag);
+}
+
+namespace cef_subtle {
+
+template <typename T>
+scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromZeroTag) {
+  return scoped_refptr<T>(obj);
+}
+
+template <typename T>
+scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromOneTag) {
+  return AdoptRef(obj);
+}
+
+}  // namespace cef_subtle
+
+// Constructs an instance of T, which is a ref counted type, and wraps the
+// object into a scoped_refptr<T>.
+template <typename T, typename... Args>
+scoped_refptr<T> MakeRefCounted(Args&&... args) {
+  T* obj = new T(std::forward<Args>(args)...);
+  return cef_subtle::AdoptRefIfNeeded(obj, T::kRefCountPreference);
+}
+
+// Takes an instance of T, which is a ref counted type, and wraps the object
+// into a scoped_refptr<T>.
+template <typename T>
+scoped_refptr<T> WrapRefCounted(T* t) {
+  return scoped_refptr<T>(t);
+}
+
+}  // namespace base
+
+//
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+//
+//   class MyFoo : public RefCounted<MyFoo> {
+//    ...
+//    private:
+//     friend class RefCounted<MyFoo>;  // Allow destruction by RefCounted<>.
+//     ~MyFoo();                        // Destructor must be private/protected.
+//   };
+//
+//   void some_function() {
+//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+//     foo->Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+//     ...
+//     foo.reset();  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo->Method(param);
+//   }
+//
+// The above examples show how scoped_refptr<T> acts like a pointer to T.
+// Given two scoped_refptr<T> classes, it is also possible to exchange
+// references between the two objects, like so:
+//
+//   {
+//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+//     scoped_refptr<MyFoo> b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references nullptr.
+//   }
+//
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+//
+//   {
+//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+//     scoped_refptr<MyFoo> b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//   }
+//
+// Also see Chromium's ownership and calling conventions:
+// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions
+// Specifically:
+//   If the function (at least sometimes) takes a ref on a refcounted object,
+//   declare the param as scoped_refptr<T>. The caller can decide whether it
+//   wishes to transfer ownership (by calling std::move(t) when passing t) or
+//   retain its ref (by simply passing t directly).
+//   In other words, use scoped_refptr like you would a std::unique_ptr except
+//   in the odd case where it's required to hold on to a ref while handing one
+//   to another component (if a component merely needs to use t on the stack
+//   without keeping a ref: pass t as a raw T*).
+template <class T>
+class TRIVIAL_ABI scoped_refptr {
+ public:
+  typedef T element_type;
+
+  constexpr scoped_refptr() = default;
+
+  // Allow implicit construction from nullptr.
+  constexpr scoped_refptr(std::nullptr_t) {}
+
+  // Constructs from a raw pointer. Note that this constructor allows implicit
+  // conversion from T* to scoped_refptr<T> which is strongly discouraged. If
+  // you are creating a new ref-counted object please use
+  // base::MakeRefCounted<T>() or base::WrapRefCounted<T>(). Otherwise you
+  // should move or copy construct from an existing scoped_refptr<T> to the
+  // ref-counted object.
+  scoped_refptr(T* p) : ptr_(p) {
+    if (ptr_)
+      AddRef(ptr_);
+  }
+
+  // Copy constructor. This is required in addition to the copy conversion
+  // constructor below.
+  scoped_refptr(const scoped_refptr& r) : scoped_refptr(r.ptr_) {}
+
+  // Copy conversion constructor.
+  template <typename U,
+            typename = typename std::enable_if<
+                std::is_convertible<U*, T*>::value>::type>
+  scoped_refptr(const scoped_refptr<U>& r) : scoped_refptr(r.ptr_) {}
+
+  // Move constructor. This is required in addition to the move conversion
+  // constructor below.
+  scoped_refptr(scoped_refptr&& r) noexcept : ptr_(r.ptr_) { r.ptr_ = nullptr; }
+
+  // Move conversion constructor.
+  template <typename U,
+            typename = typename std::enable_if<
+                std::is_convertible<U*, T*>::value>::type>
+  scoped_refptr(scoped_refptr<U>&& r) noexcept : ptr_(r.ptr_) {
+    r.ptr_ = nullptr;
+  }
+
+  ~scoped_refptr() {
+    static_assert(!base::cef_subtle::IsRefCountPreferenceOverridden(
+                      static_cast<T*>(nullptr), static_cast<T*>(nullptr)),
+                  "It's unsafe to override the ref count preference."
+                  " Please remove REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE"
+                  " from subclasses.");
+    if (ptr_)
+      Release(ptr_);
+  }
+
+  T* get() const { return ptr_; }
+
+  T& operator*() const {
+    DCHECK(ptr_);
+    return *ptr_;
+  }
+
+  T* operator->() const {
+    DCHECK(ptr_);
+    return ptr_;
+  }
+
+  scoped_refptr& operator=(std::nullptr_t) {
+    reset();
+    return *this;
+  }
+
+  scoped_refptr& operator=(T* p) { return *this = scoped_refptr(p); }
+
+  // Unified assignment operator.
+  scoped_refptr& operator=(scoped_refptr r) noexcept {
+    swap(r);
+    return *this;
+  }
+
+  // Sets managed object to null and releases reference to the previous managed
+  // object, if it existed.
+  void reset() { scoped_refptr().swap(*this); }
+
+  // Returns the owned pointer (if any), releasing ownership to the caller. The
+  // caller is responsible for managing the lifetime of the reference.
+  T* release() WARN_UNUSED_RESULT;
+
+  void swap(scoped_refptr& r) noexcept { std::swap(ptr_, r.ptr_); }
+
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  template <typename U>
+  bool operator==(const scoped_refptr<U>& rhs) const {
+    return ptr_ == rhs.get();
+  }
+
+  template <typename U>
+  bool operator!=(const scoped_refptr<U>& rhs) const {
+    return !operator==(rhs);
+  }
+
+  template <typename U>
+  bool operator<(const scoped_refptr<U>& rhs) const {
+    return ptr_ < rhs.get();
+  }
+
+ protected:
+  T* ptr_ = nullptr;
+
+ private:
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+  friend class ::base::SequencedTaskRunner;
+
+  // Friend access so these classes can use the constructor below as part of a
+  // binary size optimization.
+  friend class ::base::internal::BasePromise;
+  friend class ::base::WrappedPromise;
+
+  scoped_refptr(T* p, base::cef_subtle::AdoptRefTag) : ptr_(p) {}
+
+  // Friend required for move constructors that set r.ptr_ to null.
+  template <typename U>
+  friend class scoped_refptr;
+
+  // Non-inline helpers to allow:
+  //     class Opaque;
+  //     extern template class scoped_refptr<Opaque>;
+  // Otherwise the compiler will complain that Opaque is an incomplete type.
+  static void AddRef(T* ptr);
+  static void Release(T* ptr);
+};
+
+template <typename T>
+T* scoped_refptr<T>::release() {
+  T* ptr = ptr_;
+  ptr_ = nullptr;
+  return ptr;
+}
+
+// static
+template <typename T>
+void scoped_refptr<T>::AddRef(T* ptr) {
+  ptr->AddRef();
+}
+
+// static
+template <typename T>
+void scoped_refptr<T>::Release(T* ptr) {
+  ptr->Release();
+}
+
+template <typename T, typename U>
+bool operator==(const scoped_refptr<T>& lhs, const U* rhs) {
+  return lhs.get() == rhs;
+}
+
+template <typename T, typename U>
+bool operator==(const T* lhs, const scoped_refptr<U>& rhs) {
+  return lhs == rhs.get();
+}
+
+template <typename T>
+bool operator==(const scoped_refptr<T>& lhs, std::nullptr_t null) {
+  return !static_cast<bool>(lhs);
+}
+
+template <typename T>
+bool operator==(std::nullptr_t null, const scoped_refptr<T>& rhs) {
+  return !static_cast<bool>(rhs);
+}
+
+template <typename T, typename U>
+bool operator!=(const scoped_refptr<T>& lhs, const U* rhs) {
+  return !operator==(lhs, rhs);
+}
+
+template <typename T, typename U>
+bool operator!=(const T* lhs, const scoped_refptr<U>& rhs) {
+  return !operator==(lhs, rhs);
+}
+
+template <typename T>
+bool operator!=(const scoped_refptr<T>& lhs, std::nullptr_t null) {
+  return !operator==(lhs, null);
+}
+
+template <typename T>
+bool operator!=(std::nullptr_t null, const scoped_refptr<T>& rhs) {
+  return !operator==(null, rhs);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& out, const scoped_refptr<T>& p) {
+  return out << p.get();
+}
+
+template <typename T>
+void swap(scoped_refptr<T>& lhs, scoped_refptr<T>& rhs) noexcept {
+  lhs.swap(rhs);
+}
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_SCOPED_REFPTR_H_

include/base/cef_scoped_typeref_mac.h

@@ -0,0 +1,180 @@
+// Copyright (c) 2021 Marshall A. Greenblatt. Portions copyright (c) 2013
+// 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.
+
+// ScopedTypeRef<> is patterned after std::unique_ptr<>, but maintains ownership
+// of a reference to any type that is maintained by Retain and Release methods.
+//
+// The Traits structure must provide the Retain and Release methods for type T.
+// A default ScopedTypeRefTraits is used but not defined, and should be defined
+// for each type to use this interface. For example, an appropriate definition
+// of ScopedTypeRefTraits for CGLContextObj would be:
+//
+//   template<>
+//   struct ScopedTypeRefTraits<CGLContextObj> {
+//     static CGLContextObj InvalidValue() { return nullptr; }
+//     static CGLContextObj Retain(CGLContextObj object) {
+//       CGLContextRetain(object);
+//       return object;
+//     }
+//     static void Release(CGLContextObj object) { CGLContextRelease(object); }
+//   };
+//
+// For the many types that have pass-by-pointer create functions, the function
+// InitializeInto() is provided to allow direct initialization and assumption
+// of ownership of the object. For example, continuing to use the above
+// CGLContextObj specialization:
+//
+//   base::ScopedTypeRef<CGLContextObj> context;
+//   CGLCreateContext(pixel_format, share_group, context.InitializeInto());
+//
+// For initialization with an existing object, the caller may specify whether
+// the ScopedTypeRef<> being initialized is assuming the caller's existing
+// ownership of the object (and should not call Retain in initialization) or if
+// it should not assume this ownership and must create its own (by calling
+// Retain in initialization). This behavior is based on the |policy| parameter,
+// with |ASSUME| for the former and |RETAIN| for the latter. The default policy
+// is to |ASSUME|.
+
+#ifndef CEF_INCLUDE_BASE_CEF_SCOPED_TYPEREF_MAC_H_
+#define CEF_INCLUDE_BASE_CEF_SCOPED_TYPEREF_MAC_H_
+#pragma once
+
+#if defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/mac/scoped_typeref.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_compiler_specific.h"
+#include "include/base/cef_logging.h"
+#include "include/base/internal/cef_scoped_policy.h"
+
+namespace base {
+
+template<typename T>
+struct ScopedTypeRefTraits;
+
+template<typename T, typename Traits = ScopedTypeRefTraits<T>>
+class ScopedTypeRef {
+ public:
+  using element_type = T;
+
+  explicit constexpr ScopedTypeRef(
+      element_type object = Traits::InvalidValue(),
+      base::scoped_policy::OwnershipPolicy policy = base::scoped_policy::ASSUME)
+      : object_(object) {
+    if (object_ && policy == base::scoped_policy::RETAIN)
+      object_ = Traits::Retain(object_);
+  }
+
+  ScopedTypeRef(const ScopedTypeRef<T, Traits>& that)
+      : object_(that.object_) {
+    if (object_)
+      object_ = Traits::Retain(object_);
+  }
+
+  // This allows passing an object to a function that takes its superclass.
+  template <typename R, typename RTraits>
+  explicit ScopedTypeRef(const ScopedTypeRef<R, RTraits>& that_as_subclass)
+      : object_(that_as_subclass.get()) {
+    if (object_)
+      object_ = Traits::Retain(object_);
+  }
+
+  ScopedTypeRef(ScopedTypeRef<T, Traits>&& that) : object_(that.object_) {
+    that.object_ = Traits::InvalidValue();
+  }
+
+  ~ScopedTypeRef() {
+    if (object_)
+      Traits::Release(object_);
+  }
+
+  ScopedTypeRef& operator=(const ScopedTypeRef<T, Traits>& that) {
+    reset(that.get(), base::scoped_policy::RETAIN);
+    return *this;
+  }
+
+  // This is to be used only to take ownership of objects that are created
+  // by pass-by-pointer create functions. To enforce this, require that the
+  // object be reset to NULL before this may be used.
+  element_type* InitializeInto() WARN_UNUSED_RESULT {
+    DCHECK(!object_);
+    return &object_;
+  }
+
+  void reset(const ScopedTypeRef<T, Traits>& that) {
+    reset(that.get(), base::scoped_policy::RETAIN);
+  }
+
+  void reset(element_type object = Traits::InvalidValue(),
+             base::scoped_policy::OwnershipPolicy policy =
+                 base::scoped_policy::ASSUME) {
+    if (object && policy == base::scoped_policy::RETAIN)
+      object = Traits::Retain(object);
+    if (object_)
+      Traits::Release(object_);
+    object_ = object;
+  }
+
+  bool operator==(const element_type& that) const { return object_ == that; }
+
+  bool operator!=(const element_type& that) const { return object_ != that; }
+
+  operator element_type() const { return object_; }
+
+  element_type get() const { return object_; }
+
+  void swap(ScopedTypeRef& that) {
+    element_type temp = that.object_;
+    that.object_ = object_;
+    object_ = temp;
+  }
+
+  // ScopedTypeRef<>::release() is like std::unique_ptr<>::release.  It is NOT
+  // a wrapper for Release().  To force a ScopedTypeRef<> object to call
+  // Release(), use ScopedTypeRef<>::reset().
+  element_type release() WARN_UNUSED_RESULT {
+    element_type temp = object_;
+    object_ = Traits::InvalidValue();
+    return temp;
+  }
+
+ private:
+  element_type object_;
+};
+
+}  // namespace base
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_SCOPED_TYPEREF_MAC_H_

include/base/cef_template_util.h

@@ -32,12 +32,7 @@
 #define CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_
 #pragma once
 
-#if defined(BASE_TEMPLATE_UTIL_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/template_util.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -45,170 +40,375 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include <cstddef>  // For size_t.
+#include <stddef.h>
+#include <iosfwd>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "include/base/cef_build.h"
 
+// Some versions of libstdc++ have partial support for type_traits, but misses
+// a smaller subset while removing some of the older non-standard stuff. Assume
+// that all versions below 5.0 fall in this category, along with one 5.0
+// experimental release. Test for this by consulting compiler major version,
+// the only reliable option available, so theoretically this could fail should
+// you attempt to mix an earlier version of libstdc++ with >= GCC5. But
+// that's unlikely to work out, especially as GCC5 changed ABI.
+#define CR_GLIBCXX_5_0_0 20150123
+#if (defined(__GNUC__) && __GNUC__ < 5) || \
+    (defined(__GLIBCXX__) && __GLIBCXX__ == CR_GLIBCXX_5_0_0)
+#define CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
+#endif
+
+// This hacks around using gcc with libc++ which has some incompatibilies.
+// - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
+// TODO(danakj): Remove this when android builders are all using a newer version
+// of gcc, or the android ndk is updated to a newer libc++ that works with older
+// gcc versions.
+#if !defined(__clang__) && defined(_LIBCPP_VERSION)
+#define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
+#endif
+
 namespace base {
 
-// template definitions from tr1
+template <class T> struct is_non_const_reference : std::false_type {};
+template <class T> struct is_non_const_reference<T&> : std::true_type {};
+template <class T> struct is_non_const_reference<const T&> : std::false_type {};
 
-template <class T, T v>
+namespace internal {
-struct integral_constant {
+
-  static const T value = v;
+// Implementation detail of base::void_t below.
-  typedef T value_type;
+template <typename...>
-  typedef integral_constant<T, v> type;
+struct make_void {
+  using type = void;
 };
 
-template <class T, T v>
+}  // namespace internal
-const T integral_constant<T, v>::value;
 
-typedef integral_constant<bool, true> true_type;
+// base::void_t is an implementation of std::void_t from C++17.
-typedef integral_constant<bool, false> false_type;
-
-template <class T>
-struct is_pointer : false_type {};
-template <class T>
-struct is_pointer<T*> : true_type {};
-
-// Member function pointer detection up to four params. Add more as needed
-// below. This is built-in to C++ 11, and we can remove this when we switch.
-template <typename T>
-struct is_member_function_pointer : false_type {};
-
-template <typename R, typename Z>
-struct is_member_function_pointer<R (Z::*)()> : true_type {};
-template <typename R, typename Z>
-struct is_member_function_pointer<R (Z::*)() const> : true_type {};
-
-template <typename R, typename Z, typename A>
-struct is_member_function_pointer<R (Z::*)(A)> : true_type {};
-template <typename R, typename Z, typename A>
-struct is_member_function_pointer<R (Z::*)(A) const> : true_type {};
-
-template <typename R, typename Z, typename A, typename B>
-struct is_member_function_pointer<R (Z::*)(A, B)> : true_type {};
-template <typename R, typename Z, typename A, typename B>
-struct is_member_function_pointer<R (Z::*)(A, B) const> : true_type {};
-
-template <typename R, typename Z, typename A, typename B, typename C>
-struct is_member_function_pointer<R (Z::*)(A, B, C)> : true_type {};
-template <typename R, typename Z, typename A, typename B, typename C>
-struct is_member_function_pointer<R (Z::*)(A, B, C) const> : true_type {};
-
-template <typename R,
-          typename Z,
-          typename A,
-          typename B,
-          typename C,
-          typename D>
-struct is_member_function_pointer<R (Z::*)(A, B, C, D)> : true_type {};
-template <typename R,
-          typename Z,
-          typename A,
-          typename B,
-          typename C,
-          typename D>
-struct is_member_function_pointer<R (Z::*)(A, B, C, D) const> : true_type {};
-
-template <class T, class U>
-struct is_same : public false_type {};
-template <class T>
-struct is_same<T, T> : true_type {};
-
-template <class>
-struct is_array : public false_type {};
-template <class T, size_t n>
-struct is_array<T[n]> : public true_type {};
-template <class T>
-struct is_array<T[]> : public true_type {};
-
-template <class T>
-struct is_non_const_reference : false_type {};
-template <class T>
-struct is_non_const_reference<T&> : true_type {};
-template <class T>
-struct is_non_const_reference<const T&> : false_type {};
-
-template <class T>
-struct is_const : false_type {};
-template <class T>
-struct is_const<const T> : true_type {};
-
-template <class T>
-struct is_void : false_type {};
-template <>
-struct is_void<void> : true_type {};
-
-namespace cef_internal {
-
-// Types YesType and NoType are guaranteed such that sizeof(YesType) <
-// sizeof(NoType).
-typedef char YesType;
-
-struct NoType {
-  YesType dummy[2];
-};
-
-// This class is an implementation detail for is_convertible, and you
-// don't need to know how it works to use is_convertible. For those
-// who care: we declare two different functions, one whose argument is
-// of type To and one with a variadic argument list. We give them
-// return types of different size, so we can use sizeof to trick the
-// compiler into telling us which function it would have chosen if we
-// had called it with an argument of type From.  See Alexandrescu's
-// _Modern C++ Design_ for more details on this sort of trick.
-
-struct ConvertHelper {
-  template <typename To>
-  static YesType Test(To);
-
-  template <typename To>
-  static NoType Test(...);
-
-  template <typename From>
-  static From& Create();
-};
-
-// Used to determine if a type is a struct/union/class. Inspired by Boost's
-// is_class type_trait implementation.
-struct IsClassHelper {
-  template <typename C>
-  static YesType Test(void (C::*)(void));
-
-  template <typename C>
-  static NoType Test(...);
-};
-
-}  // namespace cef_internal
-
-// Inherits from true_type if From is convertible to To, false_type otherwise.
 //
-// Note that if the type is convertible, this will be a true_type REGARDLESS
+// We use |base::internal::make_void| as a helper struct to avoid a C++14
-// of whether or not the conversion would emit a warning.
+// defect:
-template <typename From, typename To>
+//   http://en.cppreference.com/w/cpp/types/void_t
-struct is_convertible
+//   http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
-    : integral_constant<bool,
+template <typename... Ts>
-                        sizeof(cef_internal::ConvertHelper::Test<To>(
+using void_t = typename ::base::internal::make_void<Ts...>::type;
-                            cef_internal::ConvertHelper::Create<From>())) ==
+
-                            sizeof(cef_internal::YesType)> {};
+namespace internal {
+
+// Uses expression SFINAE to detect whether using operator<< would work.
+template <typename T, typename = void>
+struct SupportsOstreamOperator : std::false_type {};
+template <typename T>
+struct SupportsOstreamOperator<T,
+                               decltype(void(std::declval<std::ostream&>()
+                                             << std::declval<T>()))>
+    : std::true_type {};
+
+template <typename T, typename = void>
+struct SupportsToString : std::false_type {};
+template <typename T>
+struct SupportsToString<T, decltype(void(std::declval<T>().ToString()))>
+    : std::true_type {};
+
+// Used to detect whether the given type is an iterator.  This is normally used
+// with std::enable_if to provide disambiguation for functions that take
+// templatzed iterators as input.
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
 
 template <typename T>
-struct is_class
+struct is_iterator<T,
-    : integral_constant<bool,
+                   void_t<typename std::iterator_traits<T>::iterator_category>>
-                        sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
+    : std::true_type {};
-                            sizeof(cef_internal::YesType)> {};
 
-template <bool B, class T = void>
+// Helper to express preferences in an overload set. If more than one overload
-struct enable_if {};
+// are available for a given set of parameters the overload with the higher
+// priority will be chosen.
+template <size_t I>
+struct priority_tag : priority_tag<I - 1> {};
 
+template <>
+struct priority_tag<0> {};
+
+}  // namespace internal
+
+// is_trivially_copyable is especially hard to get right.
+// - Older versions of libstdc++ will fail to have it like they do for other
+//   type traits. This has become a subset of the second point, but used to be
+//   handled independently.
+// - An experimental release of gcc includes most of type_traits but misses
+//   is_trivially_copyable, so we still have to avoid using libstdc++ in this
+//   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
+// - When compiling libc++ from before r239653, with a gcc compiler, the
+//   std::is_trivially_copyable can fail. So we need to work around that by not
+//   using the one in libc++ in this case. This is covered by the
+//   CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX define, and is discussed in
+//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 where they point out that
+//   in libc++'s commit r239653 this is fixed by libc++ checking for gcc 5.1.
+// - In both of the above cases we are using the gcc compiler. When defining
+//   this ourselves on compiler intrinsics, the __is_trivially_copyable()
+//   intrinsic is not available on gcc before version 5.1 (see the discussion in
+//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 again), so we must check for
+//   that version.
+// - When __is_trivially_copyable() is not available because we are on gcc older
+//   than 5.1, we need to fall back to something, so we use __has_trivial_copy()
+//   instead based on what was done one-off in bit_cast() previously.
+
+// TODO(crbug.com/554293): Remove this when all platforms have this in the std
+// namespace and it works with gcc as needed.
+#if defined(CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX) || \
+    defined(CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX)
+template <typename T>
+struct is_trivially_copyable {
+// TODO(danakj): Remove this when android builders are all using a newer version
+// of gcc, or the android ndk is updated to a newer libc++ that does this for
+// us.
+#if _GNUC_VER >= 501
+  static constexpr bool value = __is_trivially_copyable(T);
+#else
+  static constexpr bool value =
+      __has_trivial_copy(T) && __has_trivial_destructor(T);
+#endif
+};
+#else
 template <class T>
-struct enable_if<true, T> {
+using is_trivially_copyable = std::is_trivially_copyable<T>;
-  typedef T type;
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
+// Workaround for g++7 and earlier family.
+// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654, without this
+// Optional<std::vector<T>> where T is non-copyable causes a compile error.
+// As we know it is not trivially copy constructible, explicitly declare so.
+template <typename T>
+struct is_trivially_copy_constructible
+    : std::is_trivially_copy_constructible<T> {};
+
+template <typename... T>
+struct is_trivially_copy_constructible<std::vector<T...>> : std::false_type {};
+#else
+// Otherwise use std::is_trivially_copy_constructible as is.
+template <typename T>
+using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
+#endif
+
+// base::in_place_t is an implementation of std::in_place_t from
+// C++17. A tag type used to request in-place construction in template vararg
+// constructors.
+
+// Specification:
+// https://en.cppreference.com/w/cpp/utility/in_place
+struct in_place_t {};
+constexpr in_place_t in_place = {};
+
+// base::in_place_type_t is an implementation of std::in_place_type_t from
+// C++17. A tag type used for in-place construction when the type to construct
+// needs to be specified, such as with base::unique_any, designed to be a
+// drop-in replacement.
+
+// Specification:
+// http://en.cppreference.com/w/cpp/utility/in_place
+template <typename T>
+struct in_place_type_t {};
+
+template <typename T>
+struct is_in_place_type_t {
+  static constexpr bool value = false;
+};
+
+template <typename... Ts>
+struct is_in_place_type_t<in_place_type_t<Ts...>> {
+  static constexpr bool value = true;
+};
+
+// C++14 implementation of C++17's std::bool_constant.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/integral_constant
+// Specification: https://wg21.link/meta.type.synop
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+
+// C++14 implementation of C++17's std::conjunction.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/conjunction
+// Specification: https://wg21.link/meta.logical#1.itemdecl:1
+template <typename...>
+struct conjunction : std::true_type {};
+
+template <typename B1>
+struct conjunction<B1> : B1 {};
+
+template <typename B1, typename... Bn>
+struct conjunction<B1, Bn...>
+    : std::conditional_t<static_cast<bool>(B1::value), conjunction<Bn...>, B1> {
+};
+
+// C++14 implementation of C++17's std::disjunction.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/disjunction
+// Specification: https://wg21.link/meta.logical#itemdecl:2
+template <typename...>
+struct disjunction : std::false_type {};
+
+template <typename B1>
+struct disjunction<B1> : B1 {};
+
+template <typename B1, typename... Bn>
+struct disjunction<B1, Bn...>
+    : std::conditional_t<static_cast<bool>(B1::value), B1, disjunction<Bn...>> {
+};
+
+// C++14 implementation of C++17's std::negation.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/negation
+// Specification: https://wg21.link/meta.logical#itemdecl:3
+template <typename B>
+struct negation : bool_constant<!static_cast<bool>(B::value)> {};
+
+// Implementation of C++17's invoke_result.
+//
+// This implementation adds references to `Functor` and `Args` to work around
+// some quirks of std::result_of. See the #Notes section of [1] for details.
+//
+// References:
+// [1] https://en.cppreference.com/w/cpp/types/result_of
+// [2] https://wg21.link/meta.trans.other#lib:invoke_result
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+template <typename Functor, typename... Args>
+using invoke_result = std::invoke_result<Functor, Args...>;
+#else
+template <typename Functor, typename... Args>
+using invoke_result = std::result_of<Functor && (Args && ...)>;
+#endif
+
+// Implementation of C++17's std::invoke_result_t.
+//
+// Reference: https://wg21.link/meta.type.synop#lib:invoke_result_t
+template <typename Functor, typename... Args>
+using invoke_result_t = typename invoke_result<Functor, Args...>::type;
+
+namespace internal {
+
+// Base case, `InvokeResult` does not have a nested type member. This means `F`
+// could not be invoked with `Args...` and thus is not invocable.
+template <typename InvokeResult, typename R, typename = void>
+struct IsInvocableImpl : std::false_type {};
+
+// Happy case, `InvokeResult` does have a nested type member. Now check whether
+// `InvokeResult::type` is convertible to `R`. Short circuit in case
+// `std::is_void<R>`.
+template <typename InvokeResult, typename R>
+struct IsInvocableImpl<InvokeResult, R, void_t<typename InvokeResult::type>>
+    : disjunction<std::is_void<R>,
+                  std::is_convertible<typename InvokeResult::type, R>> {};
+
+}  // namespace internal
+
+// Implementation of C++17's std::is_invocable_r.
+//
+// Returns whether `F` can be invoked with `Args...` and the result is
+// convertible to `R`.
+//
+// Reference: https://wg21.link/meta.rel#lib:is_invocable_r
+template <typename R, typename F, typename... Args>
+struct is_invocable_r
+    : internal::IsInvocableImpl<invoke_result<F, Args...>, R> {};
+
+// Implementation of C++17's std::is_invocable.
+//
+// Returns whether `F` can be invoked with `Args...`.
+//
+// Reference: https://wg21.link/meta.rel#lib:is_invocable
+template <typename F, typename... Args>
+struct is_invocable : is_invocable_r<void, F, Args...> {};
+
+namespace internal {
+
+// The indirection with std::is_enum<T> is required, because instantiating
+// std::underlying_type_t<T> when T is not an enum is UB prior to C++20.
+template <typename T, bool = std::is_enum<T>::value>
+struct IsScopedEnumImpl : std::false_type {};
+
+template <typename T>
+struct IsScopedEnumImpl<T, /*std::is_enum<T>::value=*/true>
+    : negation<std::is_convertible<T, std::underlying_type_t<T>>> {};
+
+}  // namespace internal
+
+// Implementation of C++23's std::is_scoped_enum
+//
+// Reference: https://en.cppreference.com/w/cpp/types/is_scoped_enum
+template <typename T>
+struct is_scoped_enum : internal::IsScopedEnumImpl<T> {};
+
+// Implementation of C++20's std::remove_cvref.
+//
+// References:
+// - https://en.cppreference.com/w/cpp/types/remove_cvref
+// - https://wg21.link/meta.trans.other#lib:remove_cvref
+template <typename T>
+struct remove_cvref {
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+// Implementation of C++20's std::remove_cvref_t.
+//
+// References:
+// - https://en.cppreference.com/w/cpp/types/remove_cvref
+// - https://wg21.link/meta.type.synop#lib:remove_cvref_t
+template <typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+
+// Simplified implementation of C++20's std::iter_value_t.
+// As opposed to std::iter_value_t, this implementation does not restrict
+// the type of `Iter` and does not consider specializations of
+// `indirectly_readable_traits`.
+//
+// Reference: https://wg21.link/readable.traits#2
+template <typename Iter>
+using iter_value_t =
+    typename std::iterator_traits<remove_cvref_t<Iter>>::value_type;
+
+// Simplified implementation of C++20's std::iter_reference_t.
+// As opposed to std::iter_reference_t, this implementation does not restrict
+// the type of `Iter`.
+//
+// Reference: https://wg21.link/iterator.synopsis#:~:text=iter_reference_t
+template <typename Iter>
+using iter_reference_t = decltype(*std::declval<Iter&>());
+
+// Simplified implementation of C++20's std::indirect_result_t. As opposed to
+// std::indirect_result_t, this implementation does not restrict the type of
+// `Func` and `Iters`.
+//
+// Reference: https://wg21.link/iterator.synopsis#:~:text=indirect_result_t
+template <typename Func, typename... Iters>
+using indirect_result_t = invoke_result_t<Func, iter_reference_t<Iters>...>;
+
+// Simplified implementation of C++20's std::projected. As opposed to
+// std::projected, this implementation does not explicitly restrict the type of
+// `Iter` and `Proj`, but rather does so implicitly by requiring
+// `indirect_result_t<Proj, Iter>` is a valid type. This is required for SFINAE
+// friendliness.
+//
+// Reference: https://wg21.link/projected
+template <typename Iter,
+          typename Proj,
+          typename IndirectResultT = indirect_result_t<Proj, Iter>>
+struct projected {
+  using value_type = remove_cvref_t<IndirectResultT>;
+
+  IndirectResultT operator*() const;  // not defined
 };
 
 }  // namespace base
 
+#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
+#undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
+
 #endif  // !USING_CHROMIUM_INCLUDES
 
 #endif  // CEF_INCLUDE_BASE_CEF_TEMPLATE_UTIL_H_

include/base/cef_thread_checker.h

@@ -32,12 +32,7 @@
 #define CEF_INCLUDE_BASE_THREAD_CHECKER_H_
 #pragma once
 
-#if defined(BASE_THREADING_THREAD_CHECKER_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/threading/thread_checker.h"
 #else  // !USING_CHROMIUM_INCLUDES

include/base/cef_trace_event.h

@@ -140,12 +140,7 @@
 #define CEF_INCLUDE_BASE_CEF_TRACE_EVENT_H_
 #pragma once
 
-#if defined(TRACE_EVENT0)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the macros provided by this header already exist.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/trace_event/trace_event.h"
 #else  // !USING_CHROMIUM_INCLUDES

include/base/cef_weak_ptr.h

@@ -29,7 +29,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Weak pointers are pointers to an object that do not affect its lifetime,
-// and which may be invalidated (i.e. reset to NULL) by the object, or its
+// and which may be invalidated (i.e. reset to nullptr) by the object, or its
 // owner, at any time, most commonly when the object is about to be deleted.
 
 // Weak pointers are useful when an object needs to be accessed safely by one
@@ -42,25 +42,24 @@
 //
 //  class Controller {
 //   public:
-//    Controller() : weak_factory_(this) {}
 //    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
 //    void WorkComplete(const Result& result) { ... }
 //   private:
 //    // Member variables should appear before the WeakPtrFactory, to ensure
 //    // that any WeakPtrs to Controller are invalidated before its members
 //    // variable's destructors are executed, rendering them invalid.
-//    WeakPtrFactory<Controller> weak_factory_;
+//    WeakPtrFactory<Controller> weak_factory_{this};
 //  };
 //
 //  class Worker {
 //   public:
-//    static void StartNew(const WeakPtr<Controller>& controller) {
+//    static void StartNew(WeakPtr<Controller> controller) {
-//      Worker* worker = new Worker(controller);
+//      Worker* worker = new Worker(std::move(controller));
 //      // Kick off asynchronous processing...
 //    }
 //   private:
-//    Worker(const WeakPtr<Controller>& controller)
+//    Worker(WeakPtr<Controller> controller)
-//        : controller_(controller) {}
+//        : controller_(std::move(controller)) {}
 //    void DidCompleteAsynchronousProcessing(const Result& result) {
 //      if (controller_)
 //        controller_->WorkComplete(result);
@@ -75,18 +74,19 @@
 // ------------------------- IMPORTANT: Thread-safety -------------------------
 
 // Weak pointers may be passed safely between threads, but must always be
-// dereferenced and invalidated on the same thread otherwise checking the
+// dereferenced and invalidated on the same ThreaddTaskRunner otherwise
-// pointer would be racey.
+// checking the pointer would be racey.
 //
 // To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
 // is dereferenced, the factory and its WeakPtrs become bound to the calling
-// thread, and cannot be dereferenced or invalidated on any other thread. Bound
+// thread or current ThreaddWorkerPool token, and cannot be dereferenced or
-// WeakPtrs can still be handed off to other threads, e.g. to use to post tasks
+// invalidated on any other task runner. Bound WeakPtrs can still be handed
-// back to object on the bound thread.
+// off to other task runners, e.g. to use to post tasks back to object on the
+// bound thread.
 //
 // If all WeakPtr objects are destroyed or invalidated then the factory is
-// unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be
+// unbound from the ThreaddTaskRunner/Thread. The WeakPtrFactory may then be
-// destroyed, or new WeakPtr objects may be used, from a different sequence.
+// destroyed, or new WeakPtr objects may be used, from a different thread.
 //
 // Thus, at least one WeakPtr object must exist and have been dereferenced on
 // the correct thread to enforce that other WeakPtr objects will enforce they
@@ -96,12 +96,7 @@
 #define CEF_INCLUDE_BASE_CEF_WEAK_PTR_H_
 #pragma once
 
-#if defined(BASE_MEMORY_WEAK_PTR_H_)
+#if defined(USING_CHROMIUM_INCLUDES)
-// Do nothing if the Chromium header has already been included.
-// This can happen in cases where Chromium code is used directly by the
-// client application. When using Chromium code directly always include
-// the Chromium header first to avoid type conflicts.
-#elif defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/memory/weak_ptr.h"
 #else  // !USING_CHROMIUM_INCLUDES
@@ -109,10 +104,12 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.
 
-#include "include/base/cef_basictypes.h"
+#include <cstddef>
+#include <type_traits>
+
+#include "include/base/cef_atomic_flag.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_ref_counted.h"
-#include "include/base/cef_template_util.h"
 #include "include/base/cef_thread_checker.h"
 
 namespace base {
@@ -122,14 +119,14 @@ class SupportsWeakPtr;
 template <typename T>
 class WeakPtr;
 
-namespace cef_internal {
+namespace internal {
 // These classes are part of the WeakPtr implementation.
 // DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
 
 class WeakReference {
  public:
-  // Although Flag is bound to a specific thread, it may be deleted from another
+  // Although Flag is bound to a specific ThreaddTaskRunner, it may be
-  // via base::WeakPtr::~WeakPtr().
+  // deleted from another via base::WeakPtr::~WeakPtr().
   class Flag : public RefCountedThreadSafe<Flag> {
    public:
     Flag();
@@ -137,23 +134,30 @@ class WeakReference {
     void Invalidate();
     bool IsValid() const;
 
+    bool MaybeValid() const;
+
+    void DetachFromThread();
+
    private:
     friend class base::RefCountedThreadSafe<Flag>;
 
     ~Flag();
 
-    // The current Chromium implementation uses SequenceChecker instead of
+    base::ThreadChecker thread_checker_;
-    // ThreadChecker to support SequencedWorkerPools. CEF does not yet expose
+    AtomicFlag invalidated_;
-    // the concept of SequencedWorkerPools.
-    ThreadChecker thread_checker_;
-    bool is_valid_;
   };
 
   WeakReference();
-  explicit WeakReference(const Flag* flag);
+  explicit WeakReference(const scoped_refptr<Flag>& flag);
   ~WeakReference();
 
-  bool is_valid() const;
+  WeakReference(WeakReference&& other) noexcept;
+  WeakReference(const WeakReference& other);
+  WeakReference& operator=(WeakReference&& other) noexcept = default;
+  WeakReference& operator=(const WeakReference& other) = default;
+
+  bool IsValid() const;
+  bool MaybeValid() const;
 
  private:
   scoped_refptr<const Flag> flag_;
@@ -166,12 +170,12 @@ class WeakReferenceOwner {
 
   WeakReference GetRef() const;
 
-  bool HasRefs() const { return flag_.get() && !flag_->HasOneRef(); }
+  bool HasRefs() const { return !flag_->HasOneRef(); }
 
   void Invalidate();
 
  private:
-  mutable scoped_refptr<WeakReference::Flag> flag_;
+  scoped_refptr<WeakReference::Flag> flag_;
 };
 
 // This class simplifies the implementation of WeakPtr's type conversion
@@ -183,10 +187,24 @@ class WeakPtrBase {
   WeakPtrBase();
   ~WeakPtrBase();
 
+  WeakPtrBase(const WeakPtrBase& other) = default;
+  WeakPtrBase(WeakPtrBase&& other) noexcept = default;
+  WeakPtrBase& operator=(const WeakPtrBase& other) = default;
+  WeakPtrBase& operator=(WeakPtrBase&& other) noexcept = default;
+
+  void reset() {
+    ref_ = internal::WeakReference();
+    ptr_ = 0;
+  }
+
  protected:
-  explicit WeakPtrBase(const WeakReference& ref);
+  WeakPtrBase(const WeakReference& ref, uintptr_t ptr);
 
   WeakReference ref_;
+
+  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
+  // value is undefined (as opposed to nullptr).
+  uintptr_t ptr_;
 };
 
 // This class provides a common implementation of common functions that would
@@ -198,13 +216,14 @@ class SupportsWeakPtrBase {
   // conversion will only compile if there is exists a Base which inherits
   // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
   // function that makes calling this easier.
+  //
+  // Precondition: t != nullptr
   template <typename Derived>
   static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
-    typedef is_convertible<Derived, cef_internal::SupportsWeakPtrBase&>
+    static_assert(
-        convertible;
+        std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
-    COMPILE_ASSERT(convertible::value,
+        "AsWeakPtr argument must inherit from SupportsWeakPtr");
-                   AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
+    return AsWeakPtrImpl<Derived>(t);
-    return AsWeakPtrImpl<Derived>(t, *t);
   }
 
  private:
@@ -212,14 +231,14 @@ class SupportsWeakPtrBase {
   // which is an instance of SupportsWeakPtr<Base>. We can then safely
   // static_cast the Base* to a Derived*.
   template <typename Derived, typename Base>
-  static WeakPtr<Derived> AsWeakPtrImpl(Derived* t,
+  static WeakPtr<Derived> AsWeakPtrImpl(SupportsWeakPtr<Base>* t) {
-                                        const SupportsWeakPtr<Base>&) {
+    WeakPtr<Base> ptr = t->AsWeakPtr();
-    WeakPtr<Base> ptr = t->Base::AsWeakPtr();
+    return WeakPtr<Derived>(
-    return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
+        ptr.ref_, static_cast<Derived*>(reinterpret_cast<Base*>(ptr.ptr_)));
   }
 };
 
-}  // namespace cef_internal
+}  // namespace internal
 
 template <typename T>
 class WeakPtrFactory;
@@ -238,81 +257,118 @@ class WeakPtrFactory;
 //     foo->method();
 //
 template <typename T>
-class WeakPtr : public cef_internal::WeakPtrBase {
+class WeakPtr : public internal::WeakPtrBase {
  public:
-  WeakPtr() : ptr_(NULL) {}
+  WeakPtr() = default;
+  WeakPtr(std::nullptr_t) {}
 
   // Allow conversion from U to T provided U "is a" T. Note that this
-  // is separate from the (implicit) copy constructor.
+  // is separate from the (implicit) copy and move constructors.
   template <typename U>
-  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {}
+  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other) {
+    // Need to cast from U* to T* to do pointer adjustment in case of multiple
+    // inheritance. This also enforces the "U is a T" rule.
+    T* t = reinterpret_cast<U*>(other.ptr_);
+    ptr_ = reinterpret_cast<uintptr_t>(t);
+  }
+  template <typename U>
+  WeakPtr(WeakPtr<U>&& other) noexcept : WeakPtrBase(std::move(other)) {
+    // Need to cast from U* to T* to do pointer adjustment in case of multiple
+    // inheritance. This also enforces the "U is a T" rule.
+    T* t = reinterpret_cast<U*>(other.ptr_);
+    ptr_ = reinterpret_cast<uintptr_t>(t);
+  }
 
-  T* get() const { return ref_.is_valid() ? ptr_ : NULL; }
+  T* get() const {
+    return ref_.IsValid() ? reinterpret_cast<T*>(ptr_) : nullptr;
+  }
 
   T& operator*() const {
-    CHECK(ref_.is_valid());
+    CHECK(ref_.IsValid());
     return *get();
   }
   T* operator->() const {
-    CHECK(ref_.is_valid());
+    CHECK(ref_.IsValid());
     return get();
   }
 
-  // Allow WeakPtr<element_type> to be used in boolean expressions, but not
+  // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
-  // implicitly convertible to a real bool (which is dangerous).
+  explicit operator bool() const { return get() != nullptr; }
+
+  // Returns false if the WeakPtr is confirmed to be invalid. This call is safe
+  // to make from any thread, e.g. to optimize away unnecessary work, but
+  // operator bool() must always be called, on the correct thread, before
+  // actually using the pointer.
   //
-  // Note that this trick is only safe when the == and != operators
+  // Warning: as with any object, this call is only thread-safe if the WeakPtr
-  // are declared explicitly, as otherwise "weak_ptr1 == weak_ptr2"
+  // instance isn't being re-assigned or reset() racily with this call.
-  // will compile but do the wrong thing (i.e., convert to Testable
+  bool MaybeValid() const { return ref_.MaybeValid(); }
-  // and then do the comparison).
- private:
-  typedef T* WeakPtr::*Testable;
 
- public:
+  // Returns whether the object |this| points to has been invalidated. This can
-  operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; }
+  // be used to distinguish a WeakPtr to a destroyed object from one that has
-
+  // been explicitly set to null.
-  void reset() {
+  bool WasInvalidated() const { return ptr_ && !ref_.IsValid(); }
-    ref_ = cef_internal::WeakReference();
-    ptr_ = NULL;
-  }
 
  private:
-  // Explicitly declare comparison operators as required by the bool
+  friend class internal::SupportsWeakPtrBase;
-  // trick, but keep them private.
-  template <class U>
-  bool operator==(WeakPtr<U> const&) const;
-  template <class U>
-  bool operator!=(WeakPtr<U> const&) const;
-
-  friend class cef_internal::SupportsWeakPtrBase;
   template <typename U>
   friend class WeakPtr;
   friend class SupportsWeakPtr<T>;
   friend class WeakPtrFactory<T>;
 
-  WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
+  WeakPtr(const internal::WeakReference& ref, T* ptr)
-      : WeakPtrBase(ref), ptr_(ptr) {}
+      : WeakPtrBase(ref, reinterpret_cast<uintptr_t>(ptr)) {}
-
-  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
-  // value is undefined (as opposed to NULL).
-  T* ptr_;
 };
 
+// Allow callers to compare WeakPtrs against nullptr to test validity.
+template <class T>
+bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+  return !(weak_ptr == nullptr);
+}
+template <class T>
+bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+  return weak_ptr != nullptr;
+}
+template <class T>
+bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+  return weak_ptr.get() == nullptr;
+}
+template <class T>
+bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+  return weak_ptr == nullptr;
+}
+
+namespace internal {
+class WeakPtrFactoryBase {
+ protected:
+  WeakPtrFactoryBase(uintptr_t ptr);
+  ~WeakPtrFactoryBase();
+  internal::WeakReferenceOwner weak_reference_owner_;
+  uintptr_t ptr_;
+};
+}  // namespace internal
+
 // A class may be composed of a WeakPtrFactory and thereby
 // control how it exposes weak pointers to itself.  This is helpful if you only
 // need weak pointers within the implementation of a class.  This class is also
 // useful when working with primitive types.  For example, you could have a
 // WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
 template <class T>
-class WeakPtrFactory {
+class WeakPtrFactory : public internal::WeakPtrFactoryBase {
  public:
-  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {}
+  WeakPtrFactory() = delete;
 
-  ~WeakPtrFactory() { ptr_ = NULL; }
+  explicit WeakPtrFactory(T* ptr)
+      : WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {}
 
-  WeakPtr<T> GetWeakPtr() {
+  WeakPtrFactory(const WeakPtrFactory&) = delete;
-    DCHECK(ptr_);
+  WeakPtrFactory& operator=(const WeakPtrFactory&) = delete;
-    return WeakPtr<T>(weak_reference_owner_.GetRef(), ptr_);
+
+  ~WeakPtrFactory() = default;
+
+  WeakPtr<T> GetWeakPtr() const {
+    return WeakPtr<T>(weak_reference_owner_.GetRef(),
+                      reinterpret_cast<T*>(ptr_));
   }
 
   // Call this method to invalidate all existing weak pointers.
@@ -326,11 +382,6 @@ class WeakPtrFactory {
     DCHECK(ptr_);
     return weak_reference_owner_.HasRefs();
   }
-
- private:
-  cef_internal::WeakReferenceOwner weak_reference_owner_;
-  T* ptr_;
-  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
 };
 
 // A class may extend from SupportsWeakPtr to let others take weak pointers to
@@ -339,20 +390,22 @@ class WeakPtrFactory {
 // weak pointers to the class until after the derived class' members have been
 // destroyed, its use can lead to subtle use-after-destroy issues.
 template <class T>
-class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
+class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
  public:
-  SupportsWeakPtr() {}
+  SupportsWeakPtr() = default;
+
+  SupportsWeakPtr(const SupportsWeakPtr&) = delete;
+  SupportsWeakPtr& operator=(const SupportsWeakPtr&) = delete;
 
   WeakPtr<T> AsWeakPtr() {
     return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
   }
 
  protected:
-  ~SupportsWeakPtr() {}
+  ~SupportsWeakPtr() = default;
 
  private:
-  cef_internal::WeakReferenceOwner weak_reference_owner_;
+  internal::WeakReferenceOwner weak_reference_owner_;
-  DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
 };
 
 // Helper function that uses type deduction to safely return a WeakPtr<Derived>
@@ -375,7 +428,7 @@ class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
 
 template <typename Derived>
 WeakPtr<Derived> AsWeakPtr(Derived* t) {
-  return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
+  return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
 }
 
 }  // namespace base

include/base/internal/cef_atomicops_arm64_gcc.h

@@ -1,335 +0,0 @@
-// 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.
-//
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_GCC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_GCC_H_
-
-namespace base {
-namespace subtle {
-
-inline void MemoryBarrier() {
-  __asm__ __volatile__ ("dmb ish" ::: "memory");  // NOLINT
-}
-
-// NoBarrier versions of the operation include "memory" in the clobber list.
-// This is not required for direct usage of the NoBarrier versions of the
-// operations. However this is required for correctness when they are used as
-// part of the Acquire or Release versions, to ensure that nothing from outside
-// the call is reordered between the operation and the memory barrier. This does
-// not change the code generated, so has no or minimal impact on the
-// NoBarrier operations.
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  Atomic32 prev;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                    \n\t"
-    "ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value.
-    "cmp %w[prev], %w[old_value]           \n\t"
-    "bne 1f                                \n\t"
-    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
-    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
-    "1:                                    \n\t"
-    : [prev]"=&r" (prev),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [old_value]"IJr" (old_value),
-      [new_value]"r" (new_value)
-    : "cc", "memory"
-  );  // NOLINT
-
-  return prev;
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  Atomic32 result;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                    \n\t"
-    "ldxr %w[result], %[ptr]               \n\t"  // Load the previous value.
-    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
-    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
-    : [result]"=&r" (result),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [new_value]"r" (new_value)
-    : "memory"
-  );  // NOLINT
-
-  return result;
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  Atomic32 result;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                       \n\t"
-    "ldxr %w[result], %[ptr]                  \n\t"  // Load the previous value.
-    "add %w[result], %w[result], %w[increment]\n\t"
-    "stxr %w[temp], %w[result], %[ptr]        \n\t"  // Try to store the result.
-    "cbnz %w[temp], 0b                        \n\t"  // Retry on failure.
-    : [result]"=&r" (result),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [increment]"IJr" (increment)
-    : "memory"
-  );  // NOLINT
-
-  return result;
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  Atomic32 result;
-
-  MemoryBarrier();
-  result = NoBarrier_AtomicIncrement(ptr, increment);
-  MemoryBarrier();
-
-  return result;
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 prev;
-
-  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  MemoryBarrier();
-
-  return prev;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 prev;
-
-  MemoryBarrier();
-  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-
-  return prev;
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  __asm__ __volatile__ (  // NOLINT
-    "stlr %w[value], %[ptr]  \n\t"
-    : [ptr]"=Q" (*ptr)
-    : [value]"r" (value)
-    : "memory"
-  );  // NOLINT
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value;
-
-  __asm__ __volatile__ (  // NOLINT
-    "ldar %w[value], %[ptr]  \n\t"
-    : [value]"=r" (value)
-    : [ptr]"Q" (*ptr)
-    : "memory"
-  );  // NOLINT
-
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-// 64-bit versions of the operations.
-// See the 32-bit versions for comments.
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  Atomic64 prev;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                    \n\t"
-    "ldxr %[prev], %[ptr]                  \n\t"
-    "cmp %[prev], %[old_value]             \n\t"
-    "bne 1f                                \n\t"
-    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
-    "cbnz %w[temp], 0b                     \n\t"
-    "1:                                    \n\t"
-    : [prev]"=&r" (prev),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [old_value]"IJr" (old_value),
-      [new_value]"r" (new_value)
-    : "cc", "memory"
-  );  // NOLINT
-
-  return prev;
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  Atomic64 result;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                    \n\t"
-    "ldxr %[result], %[ptr]                \n\t"
-    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
-    "cbnz %w[temp], 0b                     \n\t"
-    : [result]"=&r" (result),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [new_value]"r" (new_value)
-    : "memory"
-  );  // NOLINT
-
-  return result;
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  Atomic64 result;
-  int32_t temp;
-
-  __asm__ __volatile__ (  // NOLINT
-    "0:                                     \n\t"
-    "ldxr %[result], %[ptr]                 \n\t"
-    "add %[result], %[result], %[increment] \n\t"
-    "stxr %w[temp], %[result], %[ptr]       \n\t"
-    "cbnz %w[temp], 0b                      \n\t"
-    : [result]"=&r" (result),
-      [temp]"=&r" (temp),
-      [ptr]"+Q" (*ptr)
-    : [increment]"IJr" (increment)
-    : "memory"
-  );  // NOLINT
-
-  return result;
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  Atomic64 result;
-
-  MemoryBarrier();
-  result = NoBarrier_AtomicIncrement(ptr, increment);
-  MemoryBarrier();
-
-  return result;
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  Atomic64 prev;
-
-  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  MemoryBarrier();
-
-  return prev;
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  Atomic64 prev;
-
-  MemoryBarrier();
-  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-
-  return prev;
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  __asm__ __volatile__ (  // NOLINT
-    "stlr %x[value], %[ptr]  \n\t"
-    : [ptr]"=Q" (*ptr)
-    : [value]"r" (value)
-    : "memory"
-  );  // NOLINT
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return *ptr;
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  Atomic64 value;
-
-  __asm__ __volatile__ (  // NOLINT
-    "ldar %x[value], %[ptr]  \n\t"
-    : [value]"=r" (value)
-    : [ptr]"Q" (*ptr)
-    : "memory"
-  );  // NOLINT
-
-  return value;
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-} }  // namespace base::subtle
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_GCC_H_
-

include/base/internal/cef_atomicops_arm64_msvc.h

@@ -1,197 +0,0 @@
-// Copyright (c) 2008 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.
-
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_MSVC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_MSVC_H_
-
-#include <windows.h>
-
-#include <intrin.h>
-
-#include "include/base/cef_macros.h"
-
-namespace base {
-namespace subtle {
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  LONG result = _InterlockedCompareExchange(
-      reinterpret_cast<volatile LONG*>(ptr), static_cast<LONG>(new_value),
-      static_cast<LONG>(old_value));
-  return static_cast<Atomic32>(result);
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  LONG result = _InterlockedExchange(reinterpret_cast<volatile LONG*>(ptr),
-                                     static_cast<LONG>(new_value));
-  return static_cast<Atomic32>(result);
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return _InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-                                 static_cast<LONG>(increment)) +
-         increment;
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return Barrier_AtomicIncrement(ptr, increment);
-}
-
-#if !(defined(_MSC_VER) && _MSC_VER >= 1400)
-#error "We require at least vs2005 for MemoryBarrier"
-#endif
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  NoBarrier_AtomicExchange(ptr, value);
-  // acts as a barrier in this implementation
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-  // See comments in Atomic64 version of Release_Store() below.
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-#if defined(_WIN64)
-
-// 64-bit low-level operations on 64-bit platform.
-
-COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic);
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  PVOID result = InterlockedCompareExchangePointer(
-      reinterpret_cast<volatile PVOID*>(ptr),
-      reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value));
-  return reinterpret_cast<Atomic64>(result);
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  PVOID result =
-      InterlockedExchangePointer(reinterpret_cast<volatile PVOID*>(ptr),
-                                 reinterpret_cast<PVOID>(new_value));
-  return reinterpret_cast<Atomic64>(result);
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr),
-                                  static_cast<LONGLONG>(increment)) +
-         increment;
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  return Barrier_AtomicIncrement(ptr, increment);
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  NoBarrier_AtomicExchange(ptr, value);
-  // acts as a barrier in this implementation
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return *ptr;
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  Atomic64 value = *ptr;
-  return value;
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-#endif  // defined(_WIN64)
-
-}  // namespace base::subtle
-}  // namespace base
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM64_MSVC_H_
-

include/base/internal/cef_atomicops_arm_gcc.h

@@ -1,325 +0,0 @@
-// Copyright (c) 2013 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.
-//
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-//
-// LinuxKernelCmpxchg and Barrier_AtomicIncrement are from Google Gears.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM_GCC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM_GCC_H_
-
-#if defined(OS_QNX)
-#include <sys/cpuinline.h>
-#endif
-
-namespace base {
-namespace subtle {
-
-// Memory barriers on ARM are funky, but the kernel is here to help:
-//
-// * ARMv5 didn't support SMP, there is no memory barrier instruction at
-//   all on this architecture, or when targeting its machine code.
-//
-// * Some ARMv6 CPUs support SMP. A full memory barrier can be produced by
-//   writing a random value to a very specific coprocessor register.
-//
-// * On ARMv7, the "dmb" instruction is used to perform a full memory
-//   barrier (though writing to the co-processor will still work).
-//   However, on single core devices (e.g. Nexus One, or Nexus S),
-//   this instruction will take up to 200 ns, which is huge, even though
-//   it's completely un-needed on these devices.
-//
-// * There is no easy way to determine at runtime if the device is
-//   single or multi-core. However, the kernel provides a useful helper
-//   function at a fixed memory address (0xffff0fa0), which will always
-//   perform a memory barrier in the most efficient way. I.e. on single
-//   core devices, this is an empty function that exits immediately.
-//   On multi-core devices, it implements a full memory barrier.
-//
-// * This source could be compiled to ARMv5 machine code that runs on a
-//   multi-core ARMv6 or ARMv7 device. In this case, memory barriers
-//   are needed for correct execution. Always call the kernel helper, even
-//   when targeting ARMv5TE.
-//
-
-inline void MemoryBarrier() {
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-  // Note: This is a function call, which is also an implicit compiler barrier.
-  typedef void (*KernelMemoryBarrierFunc)();
-  ((KernelMemoryBarrierFunc)0xffff0fa0)();
-#elif defined(OS_QNX)
-  __cpu_membarrier();
-#else
-#error MemoryBarrier() is not implemented on this platform.
-#endif
-}
-
-// An ARM toolchain would only define one of these depending on which
-// variant of the target architecture is being used. This tests against
-// any known ARMv6 or ARMv7 variant, where it is possible to directly
-// use ldrex/strex instructions to implement fast atomic operations.
-#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) ||  \
-    defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || \
-    defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) ||  \
-    defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || \
-    defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__)
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  Atomic32 prev_value;
-  int reloop;
-  do {
-    // The following is equivalent to:
-    //
-    //   prev_value = LDREX(ptr)
-    //   reloop = 0
-    //   if (prev_value != old_value)
-    //      reloop = STREX(ptr, new_value)
-    __asm__ __volatile__(
-        "    ldrex %0, [%3]\n"
-        "    mov %1, #0\n"
-        "    cmp %0, %4\n"
-#ifdef __thumb2__
-        "    it eq\n"
-#endif
-        "    strexeq %1, %5, [%3]\n"
-        : "=&r"(prev_value), "=&r"(reloop), "+m"(*ptr)
-        : "r"(ptr), "r"(old_value), "r"(new_value)
-        : "cc", "memory");
-  } while (reloop != 0);
-  return prev_value;
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 result = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  MemoryBarrier();
-  return result;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  MemoryBarrier();
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  Atomic32 value;
-  int reloop;
-  do {
-    // Equivalent to:
-    //
-    //  value = LDREX(ptr)
-    //  value += increment
-    //  reloop = STREX(ptr, value)
-    //
-    __asm__ __volatile__(
-        "    ldrex %0, [%3]\n"
-        "    add %0, %0, %4\n"
-        "    strex %1, %0, [%3]\n"
-        : "=&r"(value), "=&r"(reloop), "+m"(*ptr)
-        : "r"(ptr), "r"(increment)
-        : "cc", "memory");
-  } while (reloop);
-  return value;
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  // TODO(digit): Investigate if it's possible to implement this with
-  // a single MemoryBarrier() operation between the LDREX and STREX.
-  // See http://crbug.com/246514
-  MemoryBarrier();
-  Atomic32 result = NoBarrier_AtomicIncrement(ptr, increment);
-  MemoryBarrier();
-  return result;
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  Atomic32 old_value;
-  int reloop;
-  do {
-    // old_value = LDREX(ptr)
-    // reloop = STREX(ptr, new_value)
-    __asm__ __volatile__(
-        "   ldrex %0, [%3]\n"
-        "   strex %1, %4, [%3]\n"
-        : "=&r"(old_value), "=&r"(reloop), "+m"(*ptr)
-        : "r"(ptr), "r"(new_value)
-        : "cc", "memory");
-  } while (reloop != 0);
-  return old_value;
-}
-
-// This tests against any known ARMv5 variant.
-#elif defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5T__) || \
-    defined(__ARM_ARCH_5TE__) || defined(__ARM_ARCH_5TEJ__)
-
-// The kernel also provides a helper function to perform an atomic
-// compare-and-swap operation at the hard-wired address 0xffff0fc0.
-// On ARMv5, this is implemented by a special code path that the kernel
-// detects and treats specially when thread pre-emption happens.
-// On ARMv6 and higher, it uses LDREX/STREX instructions instead.
-//
-// Note that this always perform a full memory barrier, there is no
-// need to add calls MemoryBarrier() before or after it. It also
-// returns 0 on success, and 1 on exit.
-//
-// Available and reliable since Linux 2.6.24. Both Android and ChromeOS
-// use newer kernel revisions, so this should not be a concern.
-namespace {
-
-inline int LinuxKernelCmpxchg(Atomic32 old_value,
-                              Atomic32 new_value,
-                              volatile Atomic32* ptr) {
-  typedef int (*KernelCmpxchgFunc)(Atomic32, Atomic32, volatile Atomic32*);
-  return ((KernelCmpxchgFunc)0xffff0fc0)(old_value, new_value, ptr);
-}
-
-}  // namespace
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  Atomic32 prev_value;
-  for (;;) {
-    prev_value = *ptr;
-    if (prev_value != old_value)
-      return prev_value;
-    if (!LinuxKernelCmpxchg(old_value, new_value, ptr))
-      return old_value;
-  }
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  Atomic32 old_value;
-  do {
-    old_value = *ptr;
-  } while (LinuxKernelCmpxchg(old_value, new_value, ptr));
-  return old_value;
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return Barrier_AtomicIncrement(ptr, increment);
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  for (;;) {
-    // Atomic exchange the old value with an incremented one.
-    Atomic32 old_value = *ptr;
-    Atomic32 new_value = old_value + increment;
-    if (!LinuxKernelCmpxchg(old_value, new_value, ptr)) {
-      // The exchange took place as expected.
-      return new_value;
-    }
-    // Otherwise, *ptr changed mid-loop and we need to retry.
-  }
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 prev_value;
-  for (;;) {
-    prev_value = *ptr;
-    if (prev_value != old_value) {
-      // Always ensure acquire semantics.
-      MemoryBarrier();
-      return prev_value;
-    }
-    if (!LinuxKernelCmpxchg(old_value, new_value, ptr))
-      return old_value;
-  }
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  // This could be implemented as:
-  //    MemoryBarrier();
-  //    return NoBarrier_CompareAndSwap();
-  //
-  // But would use 3 barriers per succesful CAS. To save performance,
-  // use Acquire_CompareAndSwap(). Its implementation guarantees that:
-  // - A succesful swap uses only 2 barriers (in the kernel helper).
-  // - An early return due to (prev_value != old_value) performs
-  //   a memory barrier with no store, which is equivalent to the
-  //   generic implementation above.
-  return Acquire_CompareAndSwap(ptr, old_value, new_value);
-}
-
-#else
-#error "Your CPU's ARM architecture is not supported yet"
-#endif
-
-// NOTE: Atomicity of the following load and store operations is only
-// guaranteed in case of 32-bit alignement of |ptr| values.
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  MemoryBarrier();
-  *ptr = value;
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;
-  MemoryBarrier();
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-}  // namespace base::subtle
-}  // namespace base
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ARM_GCC_H_

include/base/internal/cef_atomicops_atomicword_compat.h

@@ -1,124 +0,0 @@
-// Copyright (c) 2011 Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_
-
-// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
-// which in turn means int. On some LP32 platforms, intptr_t is an int, but
-// on others, it's a long. When AtomicWord and Atomic32 are based on different
-// fundamental types, their pointers are incompatible.
-//
-// This file defines function overloads to allow both AtomicWord and Atomic32
-// data to be used with this interface.
-//
-// On LP64 platforms, AtomicWord and Atomic64 are both always long,
-// so this problem doesn't occur.
-
-#if !defined(ARCH_CPU_64_BITS)
-
-namespace base {
-namespace subtle {
-
-inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr,
-                                           AtomicWord old_value,
-                                           AtomicWord new_value) {
-  return NoBarrier_CompareAndSwap(reinterpret_cast<volatile Atomic32*>(ptr),
-                                  old_value, new_value);
-}
-
-inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr,
-                                           AtomicWord new_value) {
-  return NoBarrier_AtomicExchange(reinterpret_cast<volatile Atomic32*>(ptr),
-                                  new_value);
-}
-
-inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr,
-                                            AtomicWord increment) {
-  return NoBarrier_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
-                                   increment);
-}
-
-inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr,
-                                          AtomicWord increment) {
-  return Barrier_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
-                                 increment);
-}
-
-inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
-                                         AtomicWord old_value,
-                                         AtomicWord new_value) {
-  return base::subtle::Acquire_CompareAndSwap(
-      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
-}
-
-inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
-                                         AtomicWord old_value,
-                                         AtomicWord new_value) {
-  return base::subtle::Release_CompareAndSwap(
-      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  NoBarrier_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
-}
-
-inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  return base::subtle::Acquire_Store(reinterpret_cast<volatile Atomic32*>(ptr),
-                                     value);
-}
-
-inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  return base::subtle::Release_Store(reinterpret_cast<volatile Atomic32*>(ptr),
-                                     value);
-}
-
-inline AtomicWord NoBarrier_Load(volatile const AtomicWord* ptr) {
-  return NoBarrier_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
-}
-
-inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
-  return base::subtle::Acquire_Load(
-      reinterpret_cast<volatile const Atomic32*>(ptr));
-}
-
-inline AtomicWord Release_Load(volatile const AtomicWord* ptr) {
-  return base::subtle::Release_Load(
-      reinterpret_cast<volatile const Atomic32*>(ptr));
-}
-
-}  // namespace base::subtle
-}  // namespace base
-
-#endif  // !defined(ARCH_CPU_64_BITS)
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_ATOMICWORD_COMPAT_H_

include/base/internal/cef_atomicops_mac.h

@@ -1,223 +0,0 @@
-// 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.
-
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_
-
-#include <libkern/OSAtomic.h>
-
-namespace base {
-namespace subtle {
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  Atomic32 prev_value;
-  do {
-    if (OSAtomicCompareAndSwap32(old_value, new_value,
-                                 const_cast<Atomic32*>(ptr))) {
-      return old_value;
-    }
-    prev_value = *ptr;
-  } while (prev_value == old_value);
-  return prev_value;
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  Atomic32 old_value;
-  do {
-    old_value = *ptr;
-  } while (!OSAtomicCompareAndSwap32(old_value, new_value,
-                                     const_cast<Atomic32*>(ptr)));
-  return old_value;
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr));
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr));
-}
-
-inline void MemoryBarrier() {
-  OSMemoryBarrier();
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 prev_value;
-  do {
-    if (OSAtomicCompareAndSwap32Barrier(old_value, new_value,
-                                        const_cast<Atomic32*>(ptr))) {
-      return old_value;
-    }
-    prev_value = *ptr;
-  } while (prev_value == old_value);
-  return prev_value;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return Acquire_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  MemoryBarrier();
-  *ptr = value;
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;
-  MemoryBarrier();
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-#ifdef __LP64__
-
-// 64-bit implementation on 64-bit platform
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  Atomic64 prev_value;
-  do {
-    if (OSAtomicCompareAndSwap64(old_value, new_value,
-                                 reinterpret_cast<volatile int64_t*>(ptr))) {
-      return old_value;
-    }
-    prev_value = *ptr;
-  } while (prev_value == old_value);
-  return prev_value;
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  Atomic64 old_value;
-  do {
-    old_value = *ptr;
-  } while (!OSAtomicCompareAndSwap64(old_value, new_value,
-                                     reinterpret_cast<volatile int64_t*>(ptr)));
-  return old_value;
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  return OSAtomicAdd64(increment, reinterpret_cast<volatile int64_t*>(ptr));
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return OSAtomicAdd64Barrier(increment,
-                              reinterpret_cast<volatile int64_t*>(ptr));
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  Atomic64 prev_value;
-  do {
-    if (OSAtomicCompareAndSwap64Barrier(
-            old_value, new_value, reinterpret_cast<volatile int64_t*>(ptr))) {
-      return old_value;
-    }
-    prev_value = *ptr;
-  } while (prev_value == old_value);
-  return prev_value;
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  // The lib kern interface does not distinguish between
-  // Acquire and Release memory barriers; they are equivalent.
-  return Acquire_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  MemoryBarrier();
-  *ptr = value;
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return *ptr;
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  Atomic64 value = *ptr;
-  MemoryBarrier();
-  return value;
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-#endif  // defined(__LP64__)
-
-}  // namespace base::subtle
-}  // namespace base
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_

include/base/internal/cef_atomicops_x86_gcc.h

@@ -1,268 +0,0 @@
-// Copyright (c) 2011 Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_
-
-// This struct is not part of the public API of this module; clients may not
-// use it.
-// Features of this x86.  Values may not be correct before main() is run,
-// but are set conservatively.
-struct AtomicOps_x86CPUFeatureStruct {
-  bool has_amd_lock_mb_bug;  // Processor has AMD memory-barrier bug; do lfence
-                             // after acquire compare-and-swap.
-};
-extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures;
-
-#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
-
-namespace base {
-namespace subtle {
-
-// 32-bit low-level operations on any platform.
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  Atomic32 prev;
-  __asm__ __volatile__("lock; cmpxchgl %1,%2"
-                       : "=a"(prev)
-                       : "q"(new_value), "m"(*ptr), "0"(old_value)
-                       : "memory");
-  return prev;
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  __asm__ __volatile__("xchgl %1,%0"  // The lock prefix is implicit for xchg.
-                       : "=r"(new_value)
-                       : "m"(*ptr), "0"(new_value)
-                       : "memory");
-  return new_value;  // Now it's the previous value.
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  Atomic32 temp = increment;
-  __asm__ __volatile__("lock; xaddl %0,%1"
-                       : "+r"(temp), "+m"(*ptr)
-                       :
-                       : "memory");
-  // temp now holds the old value of *ptr
-  return temp + increment;
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  Atomic32 temp = increment;
-  __asm__ __volatile__("lock; xaddl %0,%1"
-                       : "+r"(temp), "+m"(*ptr)
-                       :
-                       : "memory");
-  // temp now holds the old value of *ptr
-  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
-    __asm__ __volatile__("lfence" : : : "memory");
-  }
-  return temp + increment;
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
-    __asm__ __volatile__("lfence" : : : "memory");
-  }
-  return x;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void MemoryBarrier() {
-  __asm__ __volatile__("mfence" : : : "memory");
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  ATOMICOPS_COMPILER_BARRIER();
-  *ptr = value;  // An x86 store acts as a release barrier.
-  // See comments in Atomic64 version of Release_Store(), below.
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;  // An x86 load acts as a acquire barrier.
-  // See comments in Atomic64 version of Release_Store(), below.
-  ATOMICOPS_COMPILER_BARRIER();
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-#if defined(__x86_64__)
-
-// 64-bit low-level operations on 64-bit platform.
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  Atomic64 prev;
-  __asm__ __volatile__("lock; cmpxchgq %1,%2"
-                       : "=a"(prev)
-                       : "q"(new_value), "m"(*ptr), "0"(old_value)
-                       : "memory");
-  return prev;
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  __asm__ __volatile__("xchgq %1,%0"  // The lock prefix is implicit for xchg.
-                       : "=r"(new_value)
-                       : "m"(*ptr), "0"(new_value)
-                       : "memory");
-  return new_value;  // Now it's the previous value.
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  Atomic64 temp = increment;
-  __asm__ __volatile__("lock; xaddq %0,%1"
-                       : "+r"(temp), "+m"(*ptr)
-                       :
-                       : "memory");
-  // temp now contains the previous value of *ptr
-  return temp + increment;
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  Atomic64 temp = increment;
-  __asm__ __volatile__("lock; xaddq %0,%1"
-                       : "+r"(temp), "+m"(*ptr)
-                       :
-                       : "memory");
-  // temp now contains the previous value of *ptr
-  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
-    __asm__ __volatile__("lfence" : : : "memory");
-  }
-  return temp + increment;
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  ATOMICOPS_COMPILER_BARRIER();
-
-  *ptr = value;  // An x86 store acts as a release barrier
-                 // for current AMD/Intel chips as of Jan 2008.
-                 // See also Acquire_Load(), below.
-
-  // When new chips come out, check:
-  //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
-  //  System Programming Guide, Chatper 7: Multiple-processor management,
-  //  Section 7.2, Memory Ordering.
-  // Last seen at:
-  //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
-  //
-  // x86 stores/loads fail to act as barriers for a few instructions (clflush
-  // maskmovdqu maskmovq movntdq movnti movntpd movntps movntq) but these are
-  // not generated by the compiler, and are rare.  Users of these instructions
-  // need to know about cache behaviour in any case since all of these involve
-  // either flushing cache lines or non-temporal cache hints.
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return *ptr;
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  Atomic64 value = *ptr;  // An x86 load acts as a acquire barrier,
-                          // for current AMD/Intel chips as of Jan 2008.
-                          // See also Release_Store(), above.
-  ATOMICOPS_COMPILER_BARRIER();
-  return value;
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  Atomic64 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
-    __asm__ __volatile__("lfence" : : : "memory");
-  }
-  return x;
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-#endif  // defined(__x86_64__)
-
-}  // namespace base::subtle
-}  // namespace base
-
-#undef ATOMICOPS_COMPILER_BARRIER
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_GCC_H_

include/base/internal/cef_atomicops_x86_msvc.h

@@ -1,221 +0,0 @@
-// Copyright (c) 2008 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.
-
-// Do not include this header file directly. Use base/cef_atomicops.h
-// instead.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_
-
-#include <windows.h>
-
-#include <intrin.h>
-
-#include "include/base/cef_macros.h"
-
-#if defined(ARCH_CPU_64_BITS)
-// windows.h #defines this (only on x64). This causes problems because the
-// public API also uses MemoryBarrier at the public name for this fence. So, on
-// X64, undef it, and call its documented
-// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
-// implementation directly.
-#undef MemoryBarrier
-#endif
-
-namespace base {
-namespace subtle {
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  LONG result = _InterlockedCompareExchange(
-      reinterpret_cast<volatile LONG*>(ptr), static_cast<LONG>(new_value),
-      static_cast<LONG>(old_value));
-  return static_cast<Atomic32>(result);
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  LONG result = _InterlockedExchange(reinterpret_cast<volatile LONG*>(ptr),
-                                     static_cast<LONG>(new_value));
-  return static_cast<Atomic32>(result);
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return _InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-                                 static_cast<LONG>(increment)) +
-         increment;
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return Barrier_AtomicIncrement(ptr, increment);
-}
-
-#if !(defined(_MSC_VER) && _MSC_VER >= 1400)
-#error "We require at least vs2005 for MemoryBarrier"
-#endif
-inline void MemoryBarrier() {
-#if defined(ARCH_CPU_64_BITS)
-  // See #undef and note at the top of this file.
-  __faststorefence();
-#else
-  // We use MemoryBarrier from WinNT.h
-  ::MemoryBarrier();
-#endif
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  NoBarrier_AtomicExchange(ptr, value);
-  // acts as a barrier in this implementation
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  *ptr = value;  // works w/o barrier for current Intel chips as of June 2005
-  // See comments in Atomic64 version of Release_Store() below.
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return *ptr;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;
-  return value;
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-#if defined(_WIN64)
-
-// 64-bit low-level operations on 64-bit platform.
-
-COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic);
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  PVOID result = InterlockedCompareExchangePointer(
-      reinterpret_cast<volatile PVOID*>(ptr),
-      reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value));
-  return reinterpret_cast<Atomic64>(result);
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  PVOID result =
-      InterlockedExchangePointer(reinterpret_cast<volatile PVOID*>(ptr),
-                                 reinterpret_cast<PVOID>(new_value));
-  return reinterpret_cast<Atomic64>(result);
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr),
-                                  static_cast<LONGLONG>(increment)) +
-         increment;
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  return Barrier_AtomicIncrement(ptr, increment);
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  NoBarrier_AtomicExchange(ptr, value);
-  // acts as a barrier in this implementation
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  *ptr = value;  // works w/o barrier for current Intel chips as of June 2005
-
-  // When new chips come out, check:
-  //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
-  //  System Programming Guide, Chatper 7: Multiple-processor management,
-  //  Section 7.2, Memory Ordering.
-  // Last seen at:
-  //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return *ptr;
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  Atomic64 value = *ptr;
-  return value;
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return *ptr;
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-}
-
-#endif  // defined(_WIN64)
-
-}  // namespace base::subtle
-}  // namespace base
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_X86_MSVC_H_

include/base/internal/cef_bind_internal_win.h

@@ -1,398 +0,0 @@
-// Copyright (c) 2011 Google Inc. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Do not include this header file directly. Use base/cef_bind.h instead.
-
-// Specializations of RunnableAdapter<> for Windows specific calling
-// conventions.  Please see base/bind_internal.h for more info.
-
-#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
-#define CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_
-
-// In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all
-// the same as __cdecl which would turn the following specializations into
-// multiple definitions.
-#if defined(ARCH_CPU_X86_FAMILY)
-#if defined(ARCH_CPU_32_BITS)
-
-namespace base {
-namespace cef_internal {
-
-template <typename Functor>
-class RunnableAdapter;
-
-// __stdcall Function: Arity 0.
-template <typename R>
-class RunnableAdapter<R(__stdcall*)()> {
- public:
-  typedef R(RunType)();
-
-  explicit RunnableAdapter(R(__stdcall* function)()) : function_(function) {}
-
-  R Run() { return function_(); }
-
- private:
-  R(__stdcall* function_)();
-};
-
-// __fastcall Function: Arity 0.
-template <typename R>
-class RunnableAdapter<R(__fastcall*)()> {
- public:
-  typedef R(RunType)();
-
-  explicit RunnableAdapter(R(__fastcall* function)()) : function_(function) {}
-
-  R Run() { return function_(); }
-
- private:
-  R(__fastcall* function_)();
-};
-
-// __stdcall Function: Arity 1.
-template <typename R, typename A1>
-class RunnableAdapter<R(__stdcall*)(A1)> {
- public:
-  typedef R(RunType)(A1);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1)) : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
-    return function_(a1);
-  }
-
- private:
-  R(__stdcall* function_)(A1);
-};
-
-// __fastcall Function: Arity 1.
-template <typename R, typename A1>
-class RunnableAdapter<R(__fastcall*)(A1)> {
- public:
-  typedef R(RunType)(A1);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1)) : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
-    return function_(a1);
-  }
-
- private:
-  R(__fastcall* function_)(A1);
-};
-
-// __stdcall Function: Arity 2.
-template <typename R, typename A1, typename A2>
-class RunnableAdapter<R(__stdcall*)(A1, A2)> {
- public:
-  typedef R(RunType)(A1, A2);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2) {
-    return function_(a1, a2);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2);
-};
-
-// __fastcall Function: Arity 2.
-template <typename R, typename A1, typename A2>
-class RunnableAdapter<R(__fastcall*)(A1, A2)> {
- public:
-  typedef R(RunType)(A1, A2);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2) {
-    return function_(a1, a2);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2);
-};
-
-// __stdcall Function: Arity 3.
-template <typename R, typename A1, typename A2, typename A3>
-class RunnableAdapter<R(__stdcall*)(A1, A2, A3)> {
- public:
-  typedef R(RunType)(A1, A2, A3);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3) {
-    return function_(a1, a2, a3);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2, A3);
-};
-
-// __fastcall Function: Arity 3.
-template <typename R, typename A1, typename A2, typename A3>
-class RunnableAdapter<R(__fastcall*)(A1, A2, A3)> {
- public:
-  typedef R(RunType)(A1, A2, A3);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3) {
-    return function_(a1, a2, a3);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2, A3);
-};
-
-// __stdcall Function: Arity 4.
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4) {
-    return function_(a1, a2, a3, a4);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2, A3, A4);
-};
-
-// __fastcall Function: Arity 4.
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4) {
-    return function_(a1, a2, a3, a4);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2, A3, A4);
-};
-
-// __stdcall Function: Arity 5.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5>
-class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5) {
-    return function_(a1, a2, a3, a4, a5);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2, A3, A4, A5);
-};
-
-// __fastcall Function: Arity 5.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5>
-class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5) {
-    return function_(a1, a2, a3, a4, a5);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2, A3, A4, A5);
-};
-
-// __stdcall Function: Arity 6.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6>
-class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5, A6))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5,
-        typename CallbackParamTraits<A6>::ForwardType a6) {
-    return function_(a1, a2, a3, a4, a5, a6);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2, A3, A4, A5, A6);
-};
-
-// __fastcall Function: Arity 6.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6>
-class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5, A6))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5,
-        typename CallbackParamTraits<A6>::ForwardType a6) {
-    return function_(a1, a2, a3, a4, a5, a6);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2, A3, A4, A5, A6);
-};
-
-// __stdcall Function: Arity 7.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6,
-          typename A7>
-class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
-
-  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5, A6, A7))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5,
-        typename CallbackParamTraits<A6>::ForwardType a6,
-        typename CallbackParamTraits<A7>::ForwardType a7) {
-    return function_(a1, a2, a3, a4, a5, a6, a7);
-  }
-
- private:
-  R(__stdcall* function_)(A1, A2, A3, A4, A5, A6, A7);
-};
-
-// __fastcall Function: Arity 7.
-template <typename R,
-          typename A1,
-          typename A2,
-          typename A3,
-          typename A4,
-          typename A5,
-          typename A6,
-          typename A7>
-class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
-
-  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5, A6, A7))
-      : function_(function) {}
-
-  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
-        typename CallbackParamTraits<A2>::ForwardType a2,
-        typename CallbackParamTraits<A3>::ForwardType a3,
-        typename CallbackParamTraits<A4>::ForwardType a4,
-        typename CallbackParamTraits<A5>::ForwardType a5,
-        typename CallbackParamTraits<A6>::ForwardType a6,
-        typename CallbackParamTraits<A7>::ForwardType a7) {
-    return function_(a1, a2, a3, a4, a5, a6, a7);
-  }
-
- private:
-  R(__fastcall* function_)(A1, A2, A3, A4, A5, A6, A7);
-};
-
-}  // namespace cef_internal
-}  // namespace base
-
-#endif  // defined(ARCH_CPU_32_BITS)
-#endif  // defined(ARCH_CPU_X86_FAMILY)
-
-#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_WIN_H_

include/base/internal/cef_callback_internal.h

@@ -36,72 +36,156 @@
 #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
 #define CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_
 
-#include <stddef.h>
+#include "include/base/cef_callback_forward.h"
-
-#include "include/base/cef_atomic_ref_count.h"
-#include "include/base/cef_macros.h"
 #include "include/base/cef_ref_counted.h"
-#include "include/base/cef_scoped_ptr.h"
-#include "include/base/cef_template_util.h"
-
-template <typename T>
-class ScopedVector;
 
 namespace base {
-namespace cef_internal {
-class CallbackBase;
 
-// At the base level, the only task is to add reference counting data. Don't use
+struct FakeBindState;
-// RefCountedThreadSafe since it requires the destructor to be a virtual method.
+
-// Creating a vtable for every BindState template instantiation results in a lot
+namespace internal {
-// of bloat. Its only task is to call the destructor which can be done with a
+
-// function pointer.
+class BindStateBase;
-class BindStateBase {
+class FinallyExecutorCommon;
- protected:
+class ThenAndCatchExecutorCommon;
-  explicit BindStateBase(void (*destructor)(BindStateBase*))
+
-      : ref_count_(0), destructor_(destructor) {}
+template <typename ReturnType>
-  ~BindStateBase() {}
+class PostTaskExecutor;
+
+template <typename Functor, typename... BoundArgs>
+struct BindState;
+
+class CallbackBase;
+class CallbackBaseCopyable;
+
+struct BindStateBaseRefCountTraits {
+  static void Destruct(const BindStateBase*);
+};
+
+template <typename T>
+using PassingType = std::conditional_t<std::is_scalar<T>::value, T, T&&>;
+
+// BindStateBase is used to provide an opaque handle that the Callback
+// class can use to represent a function object with bound arguments.  It
+// behaves as an existential type that is used by a corresponding
+// DoInvoke function to perform the function execution.  This allows
+// us to shield the Callback class from the types of the bound argument via
+// "type erasure."
+// At the base level, the only task is to add reference counting data. Avoid
+// using or inheriting any virtual functions. Creating a vtable for every
+// BindState template instantiation results in a lot of bloat. Its only task is
+// to call the destructor which can be done with a function pointer.
+class BindStateBase
+    : public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
+ public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
+  enum CancellationQueryMode {
+    IS_CANCELLED,
+    MAYBE_VALID,
+  };
+
+  using InvokeFuncStorage = void (*)();
+
+  BindStateBase(const BindStateBase&) = delete;
+  BindStateBase& operator=(const BindStateBase&) = delete;
 
  private:
-  friend class scoped_refptr<BindStateBase>;
+  BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                void (*destructor)(const BindStateBase*));
+  BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                void (*destructor)(const BindStateBase*),
+                bool (*query_cancellation_traits)(const BindStateBase*,
+                                                  CancellationQueryMode mode));
+
+  ~BindStateBase() = default;
+
+  friend struct BindStateBaseRefCountTraits;
+  friend class RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits>;
+
   friend class CallbackBase;
+  friend class CallbackBaseCopyable;
 
-  void AddRef();
+  // Allowlist subclasses that access the destructor of BindStateBase.
-  void Release();
+  template <typename Functor, typename... BoundArgs>
+  friend struct BindState;
+  friend struct ::base::FakeBindState;
 
-  AtomicRefCount ref_count_;
+  bool IsCancelled() const {
+    return query_cancellation_traits_(this, IS_CANCELLED);
+  }
+
+  bool MaybeValid() const {
+    return query_cancellation_traits_(this, MAYBE_VALID);
+  }
+
+  // In C++, it is safe to cast function pointers to function pointers of
+  // another type. It is not okay to use void*. We create a InvokeFuncStorage
+  // that that can store our function pointer, and then cast it back to
+  // the original type on usage.
+  InvokeFuncStorage polymorphic_invoke_;
 
   // Pointer to a function that will properly destroy |this|.
-  void (*destructor_)(BindStateBase*);
+  void (*destructor_)(const BindStateBase*);
-
+  bool (*query_cancellation_traits_)(const BindStateBase*,
-  DISALLOW_COPY_AND_ASSIGN(BindStateBase);
+                                     CancellationQueryMode mode);
 };
 
 // Holds the Callback methods that don't require specialization to reduce
 // template bloat.
+// CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
+// CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
 class CallbackBase {
  public:
+  inline CallbackBase(CallbackBase&& c) noexcept;
+  CallbackBase& operator=(CallbackBase&& c) noexcept;
+
+  explicit CallbackBase(const CallbackBaseCopyable& c);
+  CallbackBase& operator=(const CallbackBaseCopyable& c);
+
+  explicit CallbackBase(CallbackBaseCopyable&& c) noexcept;
+  CallbackBase& operator=(CallbackBaseCopyable&& c) noexcept;
+
   // Returns true if Callback is null (doesn't refer to anything).
-  bool is_null() const { return bind_state_.get() == NULL; }
+  bool is_null() const { return !bind_state_; }
+  explicit operator bool() const { return !is_null(); }
+
+  // Returns true if the callback invocation will be nop due to an cancellation.
+  // It's invalid to call this on uninitialized callback.
+  //
+  // Must be called on the Callback's destination sequence.
+  bool IsCancelled() const;
+
+  // If this returns false, the callback invocation will be a nop due to a
+  // cancellation. This may(!) still return true, even on a cancelled callback.
+  //
+  // This function is thread-safe.
+  bool MaybeValid() const;
 
   // Returns the Callback into an uninitialized state.
   void Reset();
 
  protected:
-  // In C++, it is safe to cast function pointers to function pointers of
+  friend class FinallyExecutorCommon;
-  // another type. It is not okay to use void*. We create a InvokeFuncStorage
+  friend class ThenAndCatchExecutorCommon;
-  // that that can store our function pointer, and then cast it back to
+
-  // the original type on usage.
+  template <typename ReturnType>
-  typedef void (*InvokeFuncStorage)(void);
+  friend class PostTaskExecutor;
+
+  using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
 
   // Returns true if this callback equals |other|. |other| may be null.
-  bool Equals(const CallbackBase& other) const;
+  bool EqualsInternal(const CallbackBase& other) const;
+
+  constexpr inline CallbackBase();
 
   // Allow initializing of |bind_state_| via the constructor to avoid default
-  // initialization of the scoped_refptr.  We do not also initialize
+  // initialization of the scoped_refptr.
-  // |polymorphic_invoke_| here because doing a normal assignment in the
+  explicit inline CallbackBase(BindStateBase* bind_state);
-  // derived Callback templates makes for much nicer compiler errors.
+
-  explicit CallbackBase(BindStateBase* bind_state);
+  InvokeFuncStorage polymorphic_invoke() const {
+    return bind_state_->polymorphic_invoke_;
+  }
 
   // Force the destructor to be instantiated inside this translation unit so
   // that our subclasses will not get inlined versions.  Avoids more template
@@ -109,116 +193,83 @@ class CallbackBase {
   ~CallbackBase();
 
   scoped_refptr<BindStateBase> bind_state_;
-  InvokeFuncStorage polymorphic_invoke_;
 };
 
-// A helper template to determine if given type is non-const move-only-type,
+constexpr CallbackBase::CallbackBase() = default;
-// i.e. if a value of the given type should be passed via .Pass() in a
+CallbackBase::CallbackBase(CallbackBase&&) noexcept = default;
-// destructive way.
+CallbackBase::CallbackBase(BindStateBase* bind_state)
-template <typename T>
+    : bind_state_(AdoptRef(bind_state)) {}
-struct IsMoveOnlyType {
-  template <typename U>
-  static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
 
-  template <typename U>
+// CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
-  static NoType Test(...);
+class CallbackBaseCopyable : public CallbackBase {
+ public:
+  CallbackBaseCopyable(const CallbackBaseCopyable& c);
+  CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept = default;
+  CallbackBaseCopyable& operator=(const CallbackBaseCopyable& c);
+  CallbackBaseCopyable& operator=(CallbackBaseCopyable&& c) noexcept;
 
-  static const bool value =
+ protected:
-      sizeof(Test<T>(0)) == sizeof(YesType) && !is_const<T>::value;
+  constexpr CallbackBaseCopyable() = default;
+  explicit CallbackBaseCopyable(BindStateBase* bind_state)
+      : CallbackBase(bind_state) {}
+  ~CallbackBaseCopyable() = default;
 };
 
-// This is a typetraits object that's used to take an argument type, and
+// Helpers for the `Then()` implementation.
-// extract a suitable type for storing and forwarding arguments.
+template <typename OriginalCallback, typename ThenCallback>
-//
+struct ThenHelper;
-// In particular, it strips off references, and converts arrays to
+
-// pointers for storage; and it avoids accidentally trying to create a
+// Specialization when original callback returns `void`.
-// "reference of a reference" if the argument is a reference type.
+template <template <typename> class OriginalCallback,
-//
+          template <typename>
-// This array type becomes an issue for storage because we are passing bound
+          class ThenCallback,
-// parameters by const reference. In this case, we end up passing an actual
+          typename... OriginalArgs,
-// array type in the initializer list which C++ does not allow.  This will
+          typename ThenR,
-// break passing of C-string literals.
+          typename... ThenArgs>
-template <typename T, bool is_move_only = IsMoveOnlyType<T>::value>
+struct ThenHelper<OriginalCallback<void(OriginalArgs...)>,
-struct CallbackParamTraits {
+                  ThenCallback<ThenR(ThenArgs...)>> {
-  typedef const T& ForwardType;
+  static_assert(sizeof...(ThenArgs) == 0,
-  typedef T StorageType;
+                "|then| callback cannot accept parameters if |this| has a "
+                "void return type.");
+
+  static auto CreateTrampoline() {
+    return [](OriginalCallback<void(OriginalArgs...)> c1,
+              ThenCallback<ThenR(ThenArgs...)> c2, OriginalArgs... c1_args) {
+      std::move(c1).Run(std::forward<OriginalArgs>(c1_args)...);
+      return std::move(c2).Run();
+    };
+  }
 };
 
-// The Storage should almost be impossible to trigger unless someone manually
+// Specialization when original callback returns a non-void type.
-// specifies type of the bind parameters.  However, in case they do,
+template <template <typename> class OriginalCallback,
-// this will guard against us accidentally storing a reference parameter.
+          template <typename>
-//
+          class ThenCallback,
-// The ForwardType should only be used for unbound arguments.
+          typename OriginalR,
-template <typename T>
+          typename... OriginalArgs,
-struct CallbackParamTraits<T&, false> {
+          typename ThenR,
-  typedef T& ForwardType;
+          typename... ThenArgs>
-  typedef T StorageType;
+struct ThenHelper<OriginalCallback<OriginalR(OriginalArgs...)>,
+                  ThenCallback<ThenR(ThenArgs...)>> {
+  static_assert(sizeof...(ThenArgs) == 1,
+                "|then| callback must accept exactly one parameter if |this| "
+                "has a non-void return type.");
+  // TODO(dcheng): This should probably check is_convertible as well (same with
+  // `AssertBindArgsValidity`).
+  static_assert(std::is_constructible<ThenArgs..., OriginalR&&>::value,
+                "|then| callback's parameter must be constructible from "
+                "return type of |this|.");
+
+  static auto CreateTrampoline() {
+    return [](OriginalCallback<OriginalR(OriginalArgs...)> c1,
+              ThenCallback<ThenR(ThenArgs...)> c2, OriginalArgs... c1_args) {
+      return std::move(c2).Run(
+          std::move(c1).Run(std::forward<OriginalArgs>(c1_args)...));
+    };
+  }
 };
 
-// Note that for array types, we implicitly add a const in the conversion. This
+}  // namespace internal
-// means that it is not possible to bind array arguments to functions that take
-// a non-const pointer. Trying to specialize the template based on a "const
-// T[n]" does not seem to match correctly, so we are stuck with this
-// restriction.
-template <typename T, size_t n>
-struct CallbackParamTraits<T[n], false> {
-  typedef const T* ForwardType;
-  typedef const T* StorageType;
-};
-
-// See comment for CallbackParamTraits<T[n]>.
-template <typename T>
-struct CallbackParamTraits<T[], false> {
-  typedef const T* ForwardType;
-  typedef const T* StorageType;
-};
-
-// Parameter traits for movable-but-not-copyable scopers.
-//
-// Callback<>/Bind() understands movable-but-not-copyable semantics where
-// the type cannot be copied but can still have its state destructively
-// transferred (aka. moved) to another instance of the same type by calling a
-// helper function.  When used with Bind(), this signifies transferal of the
-// object's state to the target function.
-//
-// For these types, the ForwardType must not be a const reference, or a
-// reference.  A const reference is inappropriate, and would break const
-// correctness, because we are implementing a destructive move.  A non-const
-// reference cannot be used with temporaries which means the result of a
-// function or a cast would not be usable with Callback<> or Bind().
-template <typename T>
-struct CallbackParamTraits<T, true> {
-  typedef T ForwardType;
-  typedef T StorageType;
-};
-
-// CallbackForward() is a very limited simulation of C++11's std::forward()
-// used by the Callback/Bind system for a set of movable-but-not-copyable
-// types.  It is needed because forwarding a movable-but-not-copyable
-// argument to another function requires us to invoke the proper move
-// operator to create a rvalue version of the type.  The supported types are
-// whitelisted below as overloads of the CallbackForward() function. The
-// default template compiles out to be a no-op.
-//
-// In C++11, std::forward would replace all uses of this function.  However, it
-// is impossible to implement a general std::forward with C++11 due to a lack
-// of rvalue references.
-//
-// In addition to Callback/Bind, this is used by PostTaskAndReplyWithResult to
-// simulate std::forward() and forward the result of one Callback as a
-// parameter to another callback. This is to support Callbacks that return
-// the movable-but-not-copyable types whitelisted above.
-template <typename T>
-typename enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(T& t) {
-  return t;
-}
-
-template <typename T>
-typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) {
-  return t.Pass();
-}
-
-}  // namespace cef_internal
 }  // namespace base
 
 #endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_

include/base/internal/cef_lock_impl.h

@@ -40,8 +40,6 @@
 #include <pthread.h>
 #endif
 
-#include "include/base/cef_macros.h"
-
 namespace base {
 namespace cef_internal {
 
@@ -57,6 +55,10 @@ class LockImpl {
 #endif
 
   LockImpl();
+
+  LockImpl(const LockImpl&) = delete;
+  LockImpl& operator=(const LockImpl&) = delete;
+
   ~LockImpl();
 
   // If the lock is not held, take it and return true.  If the lock is already
@@ -77,8 +79,6 @@ class LockImpl {
 
  private:
   NativeHandle native_handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(LockImpl);
 };
 
 }  // namespace cef_internal

include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h

@@ -32,10 +32,9 @@
 #ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
 #define CEF_INCLUDE_BASE_INTERNAL_CEF_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
 
-#include "include/base/cef_build.h"
+#include <type_traits>
-#include "include/base/cef_ref_counted.h"
+
 #include "include/base/cef_template_util.h"
-#include "include/base/cef_tuple.h"
 
 // It is dangerous to post a task with a T* argument where T is a subtype of
 // RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
@@ -46,135 +45,30 @@
 
 namespace base {
 
-namespace cef_internal {
+// This is a base internal implementation file used by task.h and callback.h.
+// Not for public consumption, so we wrap it in namespace internal.
+namespace internal {
+
+template <typename T, typename = void>
+struct IsRefCountedType : std::false_type {};
 
 template <typename T>
-struct NeedsScopedRefptrButGetsRawPtr {
+struct IsRefCountedType<T,
-#if defined(OS_WIN)
+                        void_t<decltype(std::declval<T*>()->AddRef()),
-  enum { value = base::false_type::value };
+                               decltype(std::declval<T*>()->Release())>>
-#else
+    : std::true_type {};
-  enum {
+
-    // Human readable translation: you needed to be a scoped_refptr if you are a
+// Human readable translation: you needed to be a scoped_refptr if you are a raw
-    // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
+// pointer type and are convertible to a RefCounted(Base|ThreadSafeBase) type.
-    // type.
+template <typename T>
-    value = (is_pointer<T>::value &&
+struct NeedsScopedRefptrButGetsRawPtr
-             (is_convertible<T, subtle::RefCountedBase*>::value ||
+    : conjunction<std::is_pointer<T>,
-              is_convertible<T, subtle::RefCountedThreadSafeBase*>::value))
+                  IsRefCountedType<std::remove_pointer_t<T>>> {
-  };
+  static_assert(!std::is_reference<T>::value,
-#endif
+                "NeedsScopedRefptrButGetsRawPtr requires non-reference type.");
 };
 
-template <typename Params>
+}  // namespace internal
-struct ParamsUseScopedRefptrCorrectly {
-  enum { value = 0 };
-};
-
-template <>
-struct ParamsUseScopedRefptrCorrectly<Tuple0> {
-  enum { value = 1 };
-};
-
-template <typename A>
-struct ParamsUseScopedRefptrCorrectly<Tuple1<A>> {
-  enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value };
-};
-
-template <typename A, typename B>
-struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value)
-  };
-};
-
-template <typename A, typename B, typename C>
-struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value)
-  };
-};
-
-template <typename A, typename B, typename C, typename D>
-struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-              NeedsScopedRefptrButGetsRawPtr<D>::value)
-  };
-};
-
-template <typename A, typename B, typename C, typename D, typename E>
-struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-              NeedsScopedRefptrButGetsRawPtr<D>::value ||
-              NeedsScopedRefptrButGetsRawPtr<E>::value)
-  };
-};
-
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F>
-struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-              NeedsScopedRefptrButGetsRawPtr<D>::value ||
-              NeedsScopedRefptrButGetsRawPtr<E>::value ||
-              NeedsScopedRefptrButGetsRawPtr<F>::value)
-  };
-};
-
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F,
-          typename G>
-struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-              NeedsScopedRefptrButGetsRawPtr<D>::value ||
-              NeedsScopedRefptrButGetsRawPtr<E>::value ||
-              NeedsScopedRefptrButGetsRawPtr<F>::value ||
-              NeedsScopedRefptrButGetsRawPtr<G>::value)
-  };
-};
-
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F,
-          typename G,
-          typename H>
-struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H>> {
-  enum {
-    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-              NeedsScopedRefptrButGetsRawPtr<D>::value ||
-              NeedsScopedRefptrButGetsRawPtr<E>::value ||
-              NeedsScopedRefptrButGetsRawPtr<F>::value ||
-              NeedsScopedRefptrButGetsRawPtr<G>::value ||
-              NeedsScopedRefptrButGetsRawPtr<H>::value)
-  };
-};
-
-}  // namespace cef_internal
 
 }  // namespace base
 

include/base/internal/cef_scoped_block_mac.h

@@ -0,0 +1,66 @@
+// Copyright (c) 2013 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.
+
+// Do not include this header file directly. Use base/mac/scoped_block.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_BLOCK_MAC_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_BLOCK_MAC_H_
+
+#include <Block.h>
+
+#include "include/base/cef_scoped_typeref_mac.h"
+
+#if defined(__has_feature) && __has_feature(objc_arc)
+#error "Cannot include include/base/internal/cef_scoped_block_mac.h in file built with ARC."
+#endif
+
+namespace base {
+namespace mac {
+
+namespace internal {
+
+template <typename B>
+struct ScopedBlockTraits {
+  static B InvalidValue() { return nullptr; }
+  static B Retain(B block) { return Block_copy(block); }
+  static void Release(B block) { Block_release(block); }
+};
+
+}  // namespace internal
+
+// ScopedBlock<> is patterned after ScopedCFTypeRef<>, but uses Block_copy() and
+// Block_release() instead of CFRetain() and CFRelease().
+template <typename B>
+using ScopedBlock = ScopedTypeRef<B, internal::ScopedBlockTraits<B>>;
+
+}  // namespace mac
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_BLOCK_MAC_H_

include/base/internal/cef_scoped_policy.h

@@ -0,0 +1,53 @@
+// 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.
+
+// Do not include this header file directly. Use base/memory/scoped_policy.h
+// instead.
+
+#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_POLICY_H_
+#define CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_POLICY_H_
+
+namespace base {
+namespace scoped_policy {
+
+// Defines the ownership policy for a scoped object.
+enum OwnershipPolicy {
+  // The scoped object takes ownership of an object by taking over an existing
+  // ownership claim.
+  ASSUME,
+
+  // The scoped object will retain the object and any initial ownership is
+  // not changed.
+  RETAIN
+};
+
+}  // namespace scoped_policy
+}  // namespace base
+
+#endif  // CEF_INCLUDE_BASE_INTERNAL_CEF_SCOPED_POLICY_H_

include/capi/cef_accessibility_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c487e5fd787b1be8224a8981839e0cfdd0ed74f3$
+// $hash=306e44d49ab6198a0fa1bcea50e8a25ee18672be$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_

include/capi/cef_app_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=a4b63e6e7942e3a3961b4f7141a963980178ae6f$
+// $hash=665709ecf3ebad59e85285d319eae72197b9766f$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@@ -145,7 +145,7 @@ CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
 // This function should be called on the main application thread to shut down
 // the CEF browser process before the application exits.
 ///
-CEF_EXPORT void cef_shutdown();
+CEF_EXPORT void cef_shutdown(void);
 
 ///
 // Perform a single iteration of CEF message loop processing. This function is
@@ -162,7 +162,7 @@ CEF_EXPORT void cef_shutdown();
 // CefSettings.multi_threaded_message_loop value of false (0). This function
 // will not block.
 ///
-CEF_EXPORT void cef_do_message_loop_work();
+CEF_EXPORT void cef_do_message_loop_work(void);
 
 ///
 // Run the CEF message loop. Use this function instead of an application-
@@ -172,14 +172,14 @@ CEF_EXPORT void cef_do_message_loop_work();
 // CefSettings.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();
+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();
+CEF_EXPORT void cef_quit_message_loop(void);
 
 ///
 // Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
@@ -192,7 +192,7 @@ CEF_EXPORT void cef_set_osmodal_loop(int osModalLoop);
 // Older versions of Windows should be left DPI-unaware because they do not
 // support DirectWrite and GDI fonts are kerned very badly.
 ///
-CEF_EXPORT void cef_enable_highdpi_support();
+CEF_EXPORT void cef_enable_highdpi_support(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_audio_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=7a483ed552ecca4f1aaa03800d366beca1ea2dee$
+// $hash=62f58ab826b8a3d436655bf0855848632f2a73b5$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_
@@ -68,7 +68,7 @@ typedef struct _cef_audio_handler_t {
 
   ///
   // Called on a browser audio capture thread when the browser starts streaming
-  // audio. OnAudioSteamStopped will always be called after
+  // 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.

include/capi/cef_auth_callback_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=2b9508a328ed0218e2c576af455f8d76e5978545$
+// $hash=01a33de48ac9780f78d606d8aee2429ddb0c81a2$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_

include/capi/cef_browser_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=92c4d38f6895018f72fbafeecb13c47320ef0b1d$
+// $hash=b1c1e44e6d3842064ef6e5b9823173f7ec1fcccc$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@@ -57,10 +57,10 @@ struct _cef_browser_host_t;
 struct _cef_client_t;
 
 ///
-// Structure used to represent a browser window. When used in the browser
+// Structure used to represent a browser. When used in the browser process the
-// process the functions of this structure may be called on any thread unless
+// functions of this structure may be called on any thread unless otherwise
-// otherwise indicated in the comments. When used in the render process the
+// indicated in the comments. When used in the render process the functions of
-// functions of this structure may only be called on the main thread.
+// this structure may only be called on the main thread.
 ///
 typedef struct _cef_browser_t {
   ///
@@ -68,6 +68,12 @@ typedef struct _cef_browser_t {
   ///
   cef_base_ref_counted_t base;
 
+  ///
+  // True if this object is currently valid. This will return false (0) after
+  // cef_life_span_handler_t::OnBeforeClose is called.
+  ///
+  int(CEF_CALLBACK* is_valid)(struct _cef_browser_t* self);
+
   ///
   // Returns the browser host object. This function can only be called in the
   // browser process.
@@ -129,7 +135,7 @@ typedef struct _cef_browser_t {
                              struct _cef_browser_t* that);
 
   ///
-  // Returns true (1) if the window is a popup window.
+  // Returns true (1) if the browser is a popup.
   ///
   int(CEF_CALLBACK* is_popup)(struct _cef_browser_t* self);
 
@@ -139,17 +145,19 @@ typedef struct _cef_browser_t {
   int(CEF_CALLBACK* has_document)(struct _cef_browser_t* self);
 
   ///
-  // Returns the main (top-level) frame for the browser window. In the browser
+  // Returns the main (top-level) frame for the browser. In the browser process
-  // process this will return a valid object until after
+  // this will return a valid object until after
   // cef_life_span_handler_t::OnBeforeClose is called. In the renderer process
   // this will return NULL if the main frame is hosted in a different renderer
-  // process (e.g. for cross-origin sub-frames).
+  // process (e.g. for cross-origin sub-frames). The main frame object will
+  // change during cross-origin navigation or re-navigation after renderer
+  // process termination (due to crashes, etc).
   ///
   struct _cef_frame_t*(CEF_CALLBACK* get_main_frame)(
       struct _cef_browser_t* self);
 
   ///
-  // Returns the focused frame for the browser window.
+  // Returns the focused frame for the browser.
   ///
   struct _cef_frame_t*(CEF_CALLBACK* get_focused_frame)(
       struct _cef_browser_t* self);
@@ -197,15 +205,12 @@ typedef struct _cef_run_file_dialog_callback_t {
   cef_base_ref_counted_t base;
 
   ///
-  // Called asynchronously after the file dialog is dismissed.
+  // Called asynchronously after the file dialog is dismissed. |file_paths| will
-  // |selected_accept_filter| is the 0-based index of the value selected from
+  // be a single value or a list of values depending on the dialog mode. If the
-  // the accept filters array passed to cef_browser_host_t::RunFileDialog.
+  // selection was cancelled |file_paths| will be NULL.
-  // |file_paths| will be a single value or a list of values depending on the
-  // dialog mode. If the selection was cancelled |file_paths| will be NULL.
   ///
   void(CEF_CALLBACK* on_file_dialog_dismissed)(
       struct _cef_run_file_dialog_callback_t* self,
-      int selected_accept_filter,
       cef_string_list_t file_paths);
 } cef_run_file_dialog_callback_t;
 
@@ -278,10 +283,10 @@ typedef struct _cef_download_image_callback_t {
 } cef_download_image_callback_t;
 
 ///
-// Structure used to represent the browser process aspects of a browser window.
+// Structure used to represent the browser process aspects of a browser. The
-// The functions of this structure can only be called in the browser process.
+// functions of this structure can only be called in the browser process. They
-// They may be called on any thread in that process unless otherwise indicated
+// may be called on any thread in that process unless otherwise indicated in the
-// in the comments.
+// comments.
 ///
 typedef struct _cef_browser_host_t {
   ///
@@ -310,11 +315,12 @@ typedef struct _cef_browser_host_t {
 
   ///
   // Helper for closing a browser. Call this function from the top-level window
-  // close handler. Internally this calls CloseBrowser(false (0)) if the close
+  // close handler (if any). Internally this calls CloseBrowser(false (0)) if
-  // has not yet been initiated. This function returns false (0) while the close
+  // the close has not yet been initiated. This function returns false (0) while
-  // is pending and true (1) after the close has completed. See close_browser()
+  // the close is pending and true (1) after the close has completed. See
-  // and cef_life_span_handler_t::do_close() documentation for additional usage
+  // close_browser() and cef_life_span_handler_t::do_close() documentation for
-  // information. This function must be called on the browser process UI thread.
+  // additional usage information. This function must be called on the browser
+  // process UI thread.
   ///
   int(CEF_CALLBACK* try_close_browser)(struct _cef_browser_host_t* self);
 
@@ -324,18 +330,19 @@ typedef struct _cef_browser_host_t {
   void(CEF_CALLBACK* set_focus)(struct _cef_browser_host_t* self, int focus);
 
   ///
-  // Retrieve the window handle for this browser. If this browser is wrapped in
+  // Retrieve the window handle (if any) for this browser. If this browser is
-  // a cef_browser_view_t this function should be called on the browser process
+  // wrapped in a cef_browser_view_t this function should be called on the
-  // UI thread and it will return the handle for the top-level native window.
+  // browser process UI thread and it will return the handle for the top-level
+  // native window.
   ///
   cef_window_handle_t(CEF_CALLBACK* get_window_handle)(
       struct _cef_browser_host_t* self);
 
   ///
-  // Retrieve the window handle of the browser that opened this browser. Will
+  // Retrieve the window handle (if any) of the browser that opened this
-  // return NULL for non-popup windows or if this browser is wrapped in a
+  // browser. Will return NULL for non-popup browsers or if this browser is
-  // cef_browser_view_t. This function can be used in combination with custom
+  // wrapped in a cef_browser_view_t. This function can be used in combination
-  // handling of modal windows.
+  // with custom handling of modal windows.
   ///
   cef_window_handle_t(CEF_CALLBACK* get_opener_window_handle)(
       struct _cef_browser_host_t* self);
@@ -381,11 +388,10 @@ typedef struct _cef_browser_host_t {
   // selectable file types and may any combination of (a) valid lower-cased MIME
   // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
   // ".txt" or ".png"), or (c) combined description and file extension delimited
-  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+  // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg"). |callback| will be
-  // |selected_accept_filter| is the 0-based index of the filter that will be
+  // executed after the dialog is dismissed or immediately if another dialog is
-  // selected by default. |callback| will be executed after the dialog is
+  // already pending. The dialog will be initiated asynchronously on the UI
-  // dismissed or immediately if another dialog is already pending. The dialog
+  // thread.
-  // will be initiated asynchronously on the UI thread.
   ///
   void(CEF_CALLBACK* run_file_dialog)(
       struct _cef_browser_host_t* self,
@@ -393,7 +399,6 @@ typedef struct _cef_browser_host_t {
       const cef_string_t* title,
       const cef_string_t* default_file_path,
       cef_string_list_t accept_filters,
-      int selected_accept_filter,
       struct _cef_run_file_dialog_callback_t* callback);
 
   ///
@@ -440,18 +445,15 @@ typedef struct _cef_browser_host_t {
       struct _cef_pdf_print_callback_t* callback);
 
   ///
-  // Search for |searchText|. |identifier| must be a unique ID and these IDs
+  // Search for |searchText|. |forward| indicates whether to search forward or
-  // must strictly increase so that newer requests always have greater IDs than
+  // backward within the page. |matchCase| indicates whether the search should
-  // older requests. If |identifier| is zero or less than the previous ID value
+  // be case-sensitive. |findNext| indicates whether this is the first request
-  // then it will be automatically assigned a new valid ID. |forward| indicates
+  // or a follow-up. The search will be restarted if |searchText| or |matchCase|
-  // whether to search forward or backward within the page. |matchCase|
+  // change. The search will be stopped if |searchText| is NULL. The
-  // indicates whether the search should be case-sensitive. |findNext| indicates
+  // cef_find_handler_t instance, if any, returned via
-  // whether this is the first request or a follow-up. The cef_find_handler_t
+  // cef_client_t::GetFindHandler will be called to report find results.
-  // instance, if any, returned via cef_client_t::GetFindHandler will be called
-  // to report find results.
   ///
   void(CEF_CALLBACK* find)(struct _cef_browser_host_t* self,
-                           int identifier,
                            const cef_string_t* searchText,
                            int forward,
                            int matchCase,
@@ -671,12 +673,6 @@ typedef struct _cef_browser_host_t {
   void(CEF_CALLBACK* send_touch_event)(struct _cef_browser_host_t* self,
                                        const struct _cef_touch_event_t* event);
 
-  ///
-  // Send a focus event to the browser.
-  ///
-  void(CEF_CALLBACK* send_focus_event)(struct _cef_browser_host_t* self,
-                                       int setFocus);
-
   ///
   // Send a capture lost event to the browser.
   ///
@@ -913,9 +909,9 @@ typedef struct _cef_browser_host_t {
 } cef_browser_host_t;
 
 ///
-// Create a new browser window using the window parameters specified by
+// Create a new browser using the window parameters specified by |windowInfo|.
-// |windowInfo|. All values will be copied internally and the actual window will
+// All values will be copied internally and the actual window (if any) will be
-// be created on the UI thread. If |request_context| is NULL the global request
+// created on the UI thread. If |request_context| is NULL the global request
 // context will be used. This function can be called on any browser process
 // thread and will not block. The optional |extra_info| parameter provides an
 // opportunity to specify extra information specific to the created browser that
@@ -931,11 +927,11 @@ CEF_EXPORT int cef_browser_host_create_browser(
     struct _cef_request_context_t* request_context);
 
 ///
-// Create a new browser window using the window parameters specified by
+// Create a new browser using the window parameters specified by |windowInfo|.
-// |windowInfo|. If |request_context| is NULL the global request context will be
+// If |request_context| is NULL the global request context will be used. This
-// used. This function can only be called on the browser process UI thread. The
+// function can only be called on the browser process UI thread. The optional
-// optional |extra_info| parameter provides an opportunity to specify extra
+// |extra_info| parameter provides an opportunity to specify extra information
-// information specific to the created browser that will be passed to
+// specific to the created browser that will be passed to
 // cef_render_process_handler_t::on_browser_created() in the render process.
 ///
 CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(

include/capi/cef_browser_process_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=ade537f836add7fe0b5fd94ceba26d678abb3e43$
+// $hash=ad0a78715daff99c1ec987800b7e5d62196e7100$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
@@ -70,9 +70,9 @@ typedef struct _cef_browser_process_handler_t {
   ///
   // 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 or plugin process. Provides an
+  // process IO thread when launching a GPU process. Provides an opportunity to
-  // opportunity to modify the child process command line. Do not keep a
+  // modify the child process command line. Do not keep a reference to
-  // reference to |command_line| outside of this function.
+  // |command_line| outside of this function.
   ///
   void(CEF_CALLBACK* on_before_child_process_launch)(
       struct _cef_browser_process_handler_t* self,

include/capi/cef_callback_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=cd8c183355a6808abd763ecc0396b5da6c15b3f9$
+// $hash=10ef5088ce2a5c6ffb38f8864d3aad6e5ac88b40$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_

include/capi/cef_client_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=14eca959988209ba8f95037a47192fd50d64f2f1$
+// $hash=03ae4ba9762510e2b0c19ea29322c20ebaf2e683$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@@ -42,6 +42,7 @@
 
 #include "include/capi/cef_audio_handler_capi.h"
 #include "include/capi/cef_base_capi.h"
+#include "include/capi/cef_command_handler_capi.h"
 #include "include/capi/cef_context_menu_handler_capi.h"
 #include "include/capi/cef_dialog_handler_capi.h"
 #include "include/capi/cef_display_handler_capi.h"
@@ -49,10 +50,12 @@
 #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"
@@ -77,6 +80,13 @@ typedef struct _cef_client_t {
   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.
@@ -122,6 +132,20 @@ typedef struct _cef_client_t {
   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.
@@ -168,8 +192,8 @@ typedef struct _cef_client_t {
 
   ///
   // Called when a new message is received from a different process. Return true
-  // (1) if the message was handled or false (0) otherwise. Do not keep a
+  // (1) if the message was handled or false (0) otherwise.  It is safe to keep
-  // reference to or attempt to access the message outside of this callback.
+  // a reference to |message| outside of this callback.
   ///
   int(CEF_CALLBACK* on_process_message_received)(
       struct _cef_client_t* self,

include/capi/cef_command_handler_capi.h

@@ -0,0 +1,80 @@
+// 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=54332b79c057df9c8f3be56cc77f1daf877b3ac1$
+//
+
+#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);
+} cef_command_handler_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_COMMAND_HANDLER_CAPI_H_

include/capi/cef_command_line_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5af5bf1e877dd53f21f751d332a9e2166817324c$
+// $hash=3049c9960a95d32d61cc57ae998c0eba12820673$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
@@ -53,8 +53,9 @@ extern "C" {
 // 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 are considered case-insensitive. This structure can
+// arguments. Switch names should be lowercase ASCII and will be converted to
-// be used before cef_initialize() is called.
+// 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 {
   ///
@@ -199,13 +200,13 @@ typedef struct _cef_command_line_t {
 ///
 // Create a new cef_command_line_t instance.
 ///
-CEF_EXPORT cef_command_line_t* cef_command_line_create();
+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();
+CEF_EXPORT cef_command_line_t* cef_command_line_get_global(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_context_menu_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=175779df75a1405fcc5c337a09e6322c556698ba$
+// $hash=d9498ae2e32ec124df3dd2c3017bcf415d4205f8$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@@ -74,6 +74,29 @@ typedef struct _cef_run_context_menu_callback_t {
   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.
@@ -133,16 +156,56 @@ typedef struct _cef_context_menu_handler_t {
 
   ///
   // Called when the context menu is dismissed irregardless of whether the menu
-  // was NULL or a command was selected.
+  // was canceled or a command was selected.
   ///
   void(CEF_CALLBACK* on_context_menu_dismissed)(
       struct _cef_context_menu_handler_t* self,
       struct _cef_browser_t* browser,
       struct _cef_frame_t* frame);
+
+  ///
+  // Called to allow custom display of the quick menu for a windowless browser.
+  // |location| is the top left corner of the selected region. |size| is the
+  // size of the selected region. |edit_state_flags| is a combination of flags
+  // that represent the state of the quick menu. Return true (1) if the menu
+  // will be handled and execute |callback| either synchronously or
+  // asynchronously with the selected command ID. Return false (0) to cancel the
+  // menu.
+  ///
+  int(CEF_CALLBACK* run_quick_menu)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      const cef_point_t* location,
+      const cef_size_t* size,
+      cef_quick_menu_edit_state_flags_t edit_state_flags,
+      struct _cef_run_quick_menu_callback_t* callback);
+
+  ///
+  // Called to execute a command selected from the quick menu for a windowless
+  // browser. Return true (1) if the command was handled or false (0) for the
+  // default implementation. See cef_menu_id_t for command IDs that have default
+  // implementations.
+  ///
+  int(CEF_CALLBACK* on_quick_menu_command)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      int command_id,
+      cef_event_flags_t event_flags);
+
+  ///
+  // Called when the quick menu for a windowless browser is dismissed
+  // irregardless of whether the menu was canceled or a command was selected.
+  ///
+  void(CEF_CALLBACK* on_quick_menu_dismissed)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame);
 } cef_context_menu_handler_t;
 
 ///
-// Provides information about the context menu state. The ethods of this
+// 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 {
@@ -290,8 +353,7 @@ typedef struct _cef_context_menu_params_t {
 
   ///
   // Returns true (1) if the context menu contains items specified by the
-  // renderer process (for example, plugin placeholder or pepper plugin menu
+  // renderer process.
-  // items).
   ///
   int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self);
 } cef_context_menu_params_t;

include/capi/cef_cookie_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=b19ef1c8a781f8d59276357609fe64370bb8a107$
+// $hash=d9790a35d74621e985b917935a4fca74ba7db1e0$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_

include/capi/cef_crash_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5e19231e3476eef376c2742e8d375bee7bd4ea2d$
+// $hash=5d111a67218403f78737f2c4dc92d2fd96dc125d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
@@ -136,7 +136,7 @@ extern "C" {
 // 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();
+CEF_EXPORT int cef_crash_reporting_enabled(void);
 
 ///
 // Sets or clears a specific key-value pair from the crash metadata.

include/capi/cef_devtools_message_observer_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=1a256c04042ebd4867f39e1c31def558871b2bab$
+// $hash=ec62239c2b24ff512b64ca758be825ff57fb3b6b$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_

include/capi/cef_dialog_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5ae5556e4085faf8cf17ee757f5eeac9197f75c0$
+// $hash=dc579beb1f25f9bbdb72afb4b5b381e129f84e31$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
@@ -57,14 +57,11 @@ typedef struct _cef_file_dialog_callback_t {
   cef_base_ref_counted_t base;
 
   ///
-  // Continue the file selection. |selected_accept_filter| should be the 0-based
+  // Continue the file selection. |file_paths| should be a single value or a
-  // index of the value selected from the accept filters array passed to
+  // list of values depending on the dialog mode. An NULL |file_paths| value is
-  // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
+  // treated the same as calling cancel().
-  // or a list of values depending on the dialog mode. An NULL |file_paths|
-  // value is treated the same as calling cancel().
   ///
   void(CEF_CALLBACK* cont)(struct _cef_file_dialog_callback_t* self,
-                           int selected_accept_filter,
                            cef_string_list_t file_paths);
 
   ///
@@ -93,10 +90,9 @@ typedef struct _cef_dialog_handler_t {
   // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
   // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
   // description and file extension delimited using "|" and ";" (e.g. "Image
-  // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
+  // Types|.png;.gif;.jpg"). To display a custom dialog return true (1) and
-  // the filter that should be selected by default. To display a custom dialog
+  // execute |callback| either inline or at a later time. To display the default
-  // return true (1) and execute |callback| either inline or at a later time. To
+  // dialog return false (0).
-  // display the default dialog return false (0).
   ///
   int(CEF_CALLBACK* on_file_dialog)(
       struct _cef_dialog_handler_t* self,
@@ -105,7 +101,6 @@ typedef struct _cef_dialog_handler_t {
       const cef_string_t* title,
       const cef_string_t* default_file_path,
       cef_string_list_t accept_filters,
-      int selected_accept_filter,
       struct _cef_file_dialog_callback_t* callback);
 } cef_dialog_handler_t;
 

include/capi/cef_display_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=067fd169a30bec1ad8eeacc5ab1ac750cf59640e$
+// $hash=5e52ae520b7eda3595683d428aa578bbc776956b$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@@ -154,6 +154,16 @@ typedef struct _cef_display_handler_t {
       cef_cursor_handle_t cursor,
       cef_cursor_type_t type,
       const struct _cef_cursor_info_t* custom_cursor_info);
+
+  ///
+  // Called when the browser's access to an audio and/or video source has
+  // changed.
+  ///
+  void(CEF_CALLBACK* on_media_access_change)(
+      struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser,
+      int has_video_access,
+      int has_audio_access);
 } cef_display_handler_t;
 
 #ifdef __cplusplus

include/capi/cef_dom_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=0517dc6c42fdde9fecfc4549fab1ea12b614e143$
+// $hash=ddff4ad975fc26d0abfe05799aedb597b8274ffd$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
@@ -335,7 +335,8 @@ typedef struct _cef_domnode_t {
       struct _cef_domnode_t* self);
 
   ///
-  // Returns the bounds of the element.
+  // Returns the bounds of the element in device pixels. Use
+  // "window.devicePixelRatio" to convert to/from CSS pixels.
   ///
   cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self);
 } cef_domnode_t;

include/capi/cef_download_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=f0ceb73b289072a01c45c6e7abf339a4ec924d29$
+// $hash=33862915eb4156a70794a346a090154c468763e2$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
@@ -103,6 +103,18 @@ typedef struct _cef_download_handler_t {
   ///
   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. By default the download will be canceled. Execute

include/capi/cef_download_item_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d84044bb582b029af5fa46c75f35b3da948dffd2$
+// $hash=b9f0d91dd2fdb3625365ff8b332b08e1f0ea1187$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_

include/capi/cef_drag_data_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=9663321e2be1d000ac54e195c81f210ae40773d1$
+// $hash=c99e9efb74fea2a2a99b25a694c59256f59238ab$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
@@ -199,6 +199,11 @@ typedef struct _cef_drag_data_t {
                                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.
@@ -219,7 +224,7 @@ typedef struct _cef_drag_data_t {
 ///
 // Create a new cef_drag_data_t object.
 ///
-CEF_EXPORT cef_drag_data_t* cef_drag_data_create();
+CEF_EXPORT cef_drag_data_t* cef_drag_data_create(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_drag_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=1cc1f134e68406ae3b05f7e181e12f27262772f0$
+// $hash=5b2051c42c1d4c41b85ca823d34b26bfa5de6777$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_

include/capi/cef_extension_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=5d5251098be1477705de2a21502dec2d8338ce00$
+// $hash=fcfe34c1517ebdb3f00c1f737b91361e771b820d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_

include/capi/cef_extension_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c952241dabb9d99109ebb64acba0124e43150628$
+// $hash=768e2436e54cceb2675ddd03ebdc61b5c0785bdc$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_

include/capi/cef_file_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=00d75d4f1968686cec7db84a59df89d98d8fe146$
+// $hash=e76fa23e9682bf0865319d93e4009752ac8f854f$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_

include/capi/cef_find_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=03bb69a14868a95abf3bf7b1608dc351480e307f$
+// $hash=f2e80b8637b07f19adea666e554269de4627e399$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
@@ -59,11 +59,12 @@ typedef struct _cef_find_handler_t {
 
   ///
   // Called to report find results returned by cef_browser_host_t::find().
-  // |identifer| is the identifier passed to find(), |count| is the number of
+  // |identifer| is a unique incremental identifier for the currently active
-  // matches currently identified, |selectionRect| is the location of where the
+  // search, |count| is the number of matches currently identified,
-  // match was found (in window coordinates), |activeMatchOrdinal| is the
+  // |selectionRect| is the location of where the match was found (in window
-  // current position in the search results, and |finalUpdate| is true (1) if
+  // coordinates), |activeMatchOrdinal| is the current position in the search
-  // this is the last find notification.
+  // results, and |finalUpdate| is true (1) if this is the last find
+  // notification.
   ///
   void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
                                      struct _cef_browser_t* browser,

include/capi/cef_focus_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=0fccb41381e922e9d9545ae45ba3e6cf1916c4b0$
+// $hash=a136a2679c8af339b21a89e8ae3090a9dbb8daa7$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_

include/capi/cef_frame_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=bce865a34f45e6dee8f413f0d6bd7f4c37ab55c0$
+// $hash=8527ceea6b8778d6fabc1b4ef82e4faa06ba777a$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
@@ -242,10 +242,12 @@ typedef struct _cef_frame_t {
       struct _cef_urlrequest_client_t* client);
 
   ///
-  // Send a message to the specified |target_process|. Message delivery is not
+  // Send a message to the specified |target_process|. Ownership of the message
-  // guaranteed in all cases (for example, if the browser is closing,
+  // contents will be transferred and the |message| reference will be
-  // navigating, or if the target process crashes). Send an ACK message back
+  // invalidated. Message delivery is not guaranteed in all cases (for example,
-  // from the target process if confirmation is required.
+  // if the browser is closing, navigating, or if the target process crashes).
+  // Send an ACK message back from the target process if confirmation is
+  // required.
   ///
   void(CEF_CALLBACK* send_process_message)(
       struct _cef_frame_t* self,

include/capi/cef_frame_handler_capi.h

@@ -0,0 +1,194 @@
+// 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=8f791b2d1d5bea27f9e6ca5e0db731a0a76d181c$
+//
+
+#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 recieve or execute
+// commands during this transitional period (any sent commands will be
+// discarded).
+//
+// When a new popup browser is created in a different origin from the parent
+// browser, a temporary main frame object for the popup will first be created in
+// the parent's renderer process. That temporary main frame will then be
+// discarded after the real cross-origin main frame is created in the new/target
+// renderer process. The client will recieve creation and initial navigation
+// callbacks (1) for the temporary main frame, followed by cross-origin
+// navigation callbacks (2) for the transition from the temporary main frame to
+// the real main frame. The temporary main frame may receive and execute
+// commands during this transitional period (any sent commands may be executed,
+// but the behavior is potentially undesirable since they execute in the parent
+// browser's renderer process and not the new/target renderer process).
+//
+// Callbacks will not be executed for placeholders that may be created during
+// pre-commit navigation for sub-frames that do not yet exist in the renderer
+// process. Placeholders will have cef_frame_t::get_identifier() == -4.
+//
+// The functions of this structure will be called on the UI thread unless
+// otherwise indicated.
+///
+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,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,11 +33,11 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=273af5bd01c6ab5d4df8efb2af2b4e2da9c21760$
+// $hash=c063e5f0e0c9fef71bdb56e7cc3ea775de17a3ea$
 //
 
-#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CALLBACK_CAPI_H_
+#ifndef CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
-#define CEF_INCLUDE_CAPI_CEF_REQUEST_CALLBACK_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
 #pragma once
 
 #include "include/capi/cef_base_capi.h"
@@ -47,28 +47,12 @@ extern "C" {
 #endif
 
 ///
-// Callback structure used for asynchronous continuation of url requests.
+// Returns true (1) if the application text direction is right-to-left.
 ///
-typedef struct _cef_request_callback_t {
+CEF_EXPORT int cef_is_rtl(void);
-  ///
-  // Base structure.
-  ///
-  cef_base_ref_counted_t base;
-
-  ///
-  // Continue the url request. If |allow| is true (1) the request will be
-  // continued. Otherwise, the request will be canceled.
-  ///
-  void(CEF_CALLBACK* cont)(struct _cef_request_callback_t* self, int allow);
-
-  ///
-  // Cancel the url request.
-  ///
-  void(CEF_CALLBACK* cancel)(struct _cef_request_callback_t* self);
-} cef_request_callback_t;
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // CEF_INCLUDE_CAPI_CEF_REQUEST_CALLBACK_CAPI_H_
+#endif  // CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_

include/capi/cef_image_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d9da8862142742e780086714bbd4fb44ac95cf2c$
+// $hash=bbc87eb4ecaf92c900193afef7059caedbe8ab3a$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
@@ -196,7 +196,7 @@ typedef struct _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();
+CEF_EXPORT cef_image_t* cef_image_create(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_jsdialog_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d991e2a7d1a58a013e4d3a963361fed6918f4ec3$
+// $hash=942579315e4b8c0819cd2b06becb93670310cd09$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
@@ -127,7 +127,7 @@ typedef struct _cef_jsdialog_handler_t {
       struct _cef_browser_t* browser);
 
   ///
-  // Called when the default implementation dialog is closed.
+  // Called when the dialog is closed.
   ///
   void(CEF_CALLBACK* on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
                                        struct _cef_browser_t* browser);

include/capi/cef_keyboard_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d804a2db0f9ac13afd249407c85cb8d5852508ac$
+// $hash=140d3a3ce78f5e8ab50a24a2fd6377e7a8ea3256$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_

include/capi/cef_life_span_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=d7521ac4f73dabd876344400a165d15954c770b0$
+// $hash=34a6559587adbd0dc3143989a8c6e49e0664b43e$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@@ -101,8 +101,10 @@ typedef struct _cef_life_span_handler_t {
       int* no_javascript_access);
 
   ///
-  // Called after a new browser is created. This callback will be the first
+  // Called after a new browser is created. It is now safe to begin performing
-  // notification that references |browser|.
+  // 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);
@@ -202,13 +204,14 @@ typedef struct _cef_life_span_handler_t {
   ///
   // 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 GetIdentifier or IsSame) after this callback returns.
+  // object (other than IsValid, GetIdentifier or IsSame) after this callback
-  // This callback will be the last notification that references |browser| on
+  // returns. cef_frame_handler_t callbacks related to final main frame
-  // the UI thread. Any in-progress network requests associated with |browser|
+  // destruction will arrive after this callback and cef_browser_t::IsValid will
-  // will be aborted when the browser is destroyed, and
+  // 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 function is called. See do_close()
+  // still arrive on the IO thread after this callback. See cef_frame_handler_t
-  // documentation for additional usage information.
+  // 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);

include/capi/cef_load_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=6c6a719d7cbbc01adfdc9bbe0dff6da10e06e3f3$
+// $hash=f51b6a0dbf264fa43ea3199327a5adb1044bfc04$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_

include/capi/cef_media_access_handler_capi.h

@@ -0,0 +1,108 @@
+// 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,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=79e4e38c732c0cfeef495c8a9726e105054012bb$
+// $hash=3db7459a1940c37898699cc97f69ba9249a6f1fd$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_

include/capi/cef_menu_model_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=28fa978051bd3ddff69d58e0dc8f445f64a61480$
+// $hash=9f30f2caa9eedc0d4fe963dbf0127602ffcbec61$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_

include/capi/cef_menu_model_delegate_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=edc411cb0447a6c2965cdeb5f709fe56c43ec2bb$
+// $hash=bdb670bcaa9eb9f5748900ad25bcc061155d6076$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_

include/capi/cef_navigation_entry_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=f14afbd6941bcb37b14cce81569882512c3d7194$
+// $hash=3a7dd4a6a1b5e0d9191be6c4dd2f0135f43de643$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_

include/capi/cef_origin_whitelist_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=6798e6147540596c1abac8c7457d9d1d4d99bd54$
+// $hash=26fdd1f18f30d9e2a48aeeb5c69607d9d22d69ca$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
@@ -102,7 +102,7 @@ CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
 // 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();
+CEF_EXPORT int cef_clear_cross_origin_whitelist(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_parser_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=84149324b177c47287b935dcb3d5900a33acfdf5$
+// $hash=f5e1c0fc43c6e85dbafa66975d9dc5e2bc7be69f$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_

include/capi/cef_path_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=0ae1fe7f7141eb05eb7fd44c2d41e4c576afae1e$
+// $hash=41ddd04d4efb147b05eb93816af1591ec3b61b76$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_

include/capi/cef_permission_handler_capi.h

@@ -0,0 +1,162 @@
+// 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=e902fe011f8667b64989e57ad9e72aec74b22015$
+//
+
+#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 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 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 prompt_id,
+      const cef_string_t* requesting_origin,
+      uint32 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 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_print_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=84fc58b3898f25476d9cdd260553390ba5e0b30b$
+// $hash=e26be3efc18d8c79d019c02b1d73a7ec2866b142$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_

include/capi/cef_print_settings_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=4b52323c4ce2d0ebcc3438e16fc9a9b181a58adc$
+// $hash=1a9b9718367ec8d575fbb39b73b1085b17eb0a2b$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
@@ -193,7 +193,7 @@ typedef struct _cef_print_settings_t {
 ///
 // Create a new cef_print_settings_t object.
 ///
-CEF_EXPORT cef_print_settings_t* cef_print_settings_create();
+CEF_EXPORT cef_print_settings_t* cef_print_settings_create(void);
 
 #ifdef __cplusplus
 }

include/capi/cef_process_message_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=53ff22b73527aa331d2bd96e008f4cb4f0413042$
+// $hash=026a7f827962222a1df8b62a8e7bdfbf4dce27e0$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
@@ -41,6 +41,7 @@
 #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
@@ -69,7 +70,8 @@ typedef struct _cef_process_message_t {
   int(CEF_CALLBACK* is_read_only)(struct _cef_process_message_t* self);
 
   ///
-  // Returns a writable copy of this object.
+  // 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);
@@ -82,10 +84,18 @@ typedef struct _cef_process_message_t {
       struct _cef_process_message_t* self);
 
   ///
-  // Returns the list of arguments.
+  // 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;
 
 ///

include/capi/cef_process_util_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=c476a8d22852994d9d9695db901efaef13bbfc9d$
+// $hash=1f2b752c4e314b240ce95cb3b87863c2f99534a8$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_

include/capi/cef_registration_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=8cde223bdb8d25ff163edd95da0d9e238b298016$
+// $hash=d5efa37953d0f0097fef20bc18f4938621c6b168$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_

include/capi/cef_render_handler_capi.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+// 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
@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=e4bdab963041a270edabc0954b415eb4cae8e5cb$
+// $hash=b0688a7d24b67b74a62841be60217a8e48c7228e$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
@@ -67,25 +67,27 @@ typedef struct _cef_render_handler_t {
       struct _cef_render_handler_t* self);
 
   ///
-  // Called to retrieve the root window rectangle in screen coordinates. Return
+  // Called to retrieve the root window rectangle in screen DIP coordinates.
-  // true (1) if the rectangle was provided. If this function returns false (0)
+  // Return true (1) if the rectangle was provided. If this function returns
-  // the rectangle from GetViewRect will be used.
+  // 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 which is relative to screen
+  // Called to retrieve the view rectangle in screen DIP coordinates. This
-  // coordinates. This function must always provide a non-NULL rectangle.
+  // 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 coordinates to actual screen
+  // Called to retrieve the translation from view DIP coordinates to screen
-  // coordinates. Return true (1) if the screen coordinates were provided.
+  // 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,
@@ -159,6 +161,25 @@ typedef struct _cef_render_handler_t {
                                            cef_rect_t const* dirtyRects,
                                            void* shared_handle);
 
+  ///
+  // 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 struct _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|,