Add "win-rt-app" command-line flag to disable MITIGATION_STRICT_HANDLE_CHECKS

and avoid sandboxed renderer process crash in WinRT apps (issue #2274)
Add missing override keyword (issue #2224 )
2025-06-05 21:39:12 +02:00 · 2017-09-29 11:23:31 +02:00 · 2017-09-22 16:07:08 +02:00 · 2017-09-21 16:08:29 +02:00 · 2017-09-21 13:57:40 +02:00 · 2017-09-20 11:31:31 +02:00
1537 changed files with 68201 additions and 44134 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -46,7 +46,4 @@ Thumbs.db
 /binary_distrib
 /docs
 # CEF generated files
-/include/cef_pack_resources.h
-/include/cef_pack_strings.h
 /include/cef_version.h
-/patch/patch_state.h
--- a/.style.cfg
+++ b/.style.cfg
@@ -0,0 +1,9 @@
+# Copyright (c) 2017 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
+
+# Configuration settings for tools/fix_style.py
+{
+  # Directories containing these path components will be ignored.
+  'ignore_directories': ['yapf'],
+}
--- a/.style.yapf
+++ b/.style.yapf
@@ -0,0 +1,2 @@
+[style]
+based_on_style = chromium
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -118,7 +118,6 @@ if (is_linux) {
 }
 if (is_mac) {
  import("//build/config/mac/rules.gni")
-  import("//build_overrides/v8.gni")
  import("//build/mac/tweak_info_plist.gni")
  import("//build/util/version.gni")
  import("//media/cdm/ppapi/cdm_paths.gni")
@@ -141,18 +140,11 @@ assert(!enable_print_preview)
 # Enable support for Widevine CDM.
 assert(enable_widevine)

-# Disable support for plugin installation.
-assert(!enable_plugin_installation)
-
 if (is_clang) {
  # Don't use the chrome style plugin.
  assert(!clang_use_chrome_plugins)
 }

-# CEF does not currently support component builds. See
-# https://bitbucket.org/chromiumembedded/cef/issues/1617
-assert(!is_component_build)
-
 if (is_mac) {
  # Always generate dSYM files. The make_distrib script will fail if
  # enable_dsyms=true is not explicitly set when is_official_build=false.
@@ -248,6 +240,90 @@ config("libcef_static_config") {
  ]
 }

+# Target for building code that accesses Blink internals. Included from the
+# //third_party/WebKit/Source/web target.
+source_set("webkit_set") {
+  sources = [
+    "libcef/renderer/webkit_glue.cc",
+    "libcef/renderer/webkit_glue.h",
+  ]
+
+  configs += [
+    ":libcef_static_config",
+    "//build/config:precompiled_headers",
+
+    # Blink-internal include paths.
+    "//third_party/WebKit/Source/core:core_include_dirs",
+  ]
+
+  include_dirs = [
+    # Blink code uses paths relative to these directories. We need them because
+    # we include Blink headers.
+    "//third_party/WebKit",
+    "//third_party/WebKit/public/platform",
+    "//third_party/WebKit/public/web",
+    "//third_party/WebKit/Source",
+    "$root_gen_dir/blink",
+    "$root_gen_dir/third_party/WebKit",
+  ]
+
+  defines = [
+    # Blink-internal defines.
+    "BLINK_IMPLEMENTATION=1",
+    "BLINK_WEB_IMPLEMENTATION=1",
+    "INSIDE_BLINK",
+  ]
+
+  deps = [
+    "//skia",
+    "//third_party/icu",
+    "//third_party/boringssl",
+    "//v8",
+  ]
+}
+
+if (is_win) {
+  # Target for building code that accesses chrome_elf internals. Included from
+  # the //chrome_elf:crash target. Defined as a static_library instead of a
+  # source_set because (a) the source files don't export any symbols and (b)
+  # *_switches.cc duplication otherwise causes linker errors.
+  static_library("chrome_elf_set") {
+    sources = [
+      "libcef/common/crash_reporter_client.cc",
+      "libcef/common/crash_reporter_client.h",
+
+      # Required for crash_keys::GetChromeCrashKeys.
+      # Otherwise we need to copy this array into CEF, which would be difficult
+      # to maintain.
+      "//chrome/common/crash_keys.cc",
+      "//chrome/common/chrome_switches.cc",
+      "//components/flags_ui/flags_ui_switches.cc",
+      "//content/public/common/content_switches.cc",
+    ]
+
+    configs += [
+      ":libcef_static_config",
+      "//build/config:precompiled_headers",
+    ]
+
+    if (is_component_build) {
+      # Avoid linker errors with content_switches.cc in component build by not
+      # defining CONTENT_EXPORT.
+      defines = ["COMPILE_CONTENT_STATICALLY"]
+    }
+
+    deps = [
+      "//components/crash/core/common",  # crash_keys
+      "//gpu/config:crash_keys",
+
+      # Required by chrome_switches.cc
+      "//chrome/common:features",
+      "//ppapi/features:features",
+      "//printing/features:features",
+    ]
+  }
+}
+
 static_library("libcef_static") {
  sources = gypi_paths2.includes_common +
            gypi_paths.autogen_cpp_includes + [
@@ -352,6 +428,7 @@ static_library("libcef_static") {
    "libcef/browser/net/chrome_scheme_handler.h",
    "libcef/browser/net/cookie_store_proxy.cc",
    "libcef/browser/net/cookie_store_proxy.h",
+    "libcef/browser/net/crlset_file_util_impl.cc",
    "libcef/browser/net/devtools_scheme_handler.cc",
    "libcef/browser/net/devtools_scheme_handler.h",
    "libcef/browser/net/internal_scheme_handler.cc",
@@ -384,6 +461,8 @@ static_library("libcef_static") {
    "libcef/browser/origin_whitelist_impl.h",
    "libcef/browser/osr/browser_platform_delegate_osr.cc",
    "libcef/browser/osr/browser_platform_delegate_osr.h",
+    "libcef/browser/osr/osr_accessibility_util.cc",
+    "libcef/browser/osr/osr_accessibility_util.h",
    "libcef/browser/osr/osr_util.cc",
    "libcef/browser/osr/osr_util.h",
    "libcef/browser/osr/render_widget_host_view_osr.cc",
@@ -407,6 +486,8 @@ static_library("libcef_static") {
    "libcef/browser/plugins/plugin_service_filter.h",
    "libcef/browser/prefs/browser_prefs.cc",
    "libcef/browser/prefs/browser_prefs.h",
+    "libcef/browser/prefs/pref_store.cc",
+    "libcef/browser/prefs/pref_store.h",
    "libcef/browser/prefs/renderer_prefs.cc",
    "libcef/browser/prefs/renderer_prefs.h",
    "libcef/browser/print_settings_impl.cc",
@@ -552,6 +633,8 @@ static_library("libcef_static") {
    "libcef/renderer/plugins/plugin_preroller.h",
    "libcef/renderer/render_frame_observer.cc",
    "libcef/renderer/render_frame_observer.h",
+    "libcef/renderer/render_frame_util.cc",
+    "libcef/renderer/render_frame_util.h",
    "libcef/renderer/render_message_filter.cc",
    "libcef/renderer/render_message_filter.h",
    "libcef/renderer/render_thread_observer.cc",
@@ -561,8 +644,6 @@ static_library("libcef_static") {
    "libcef/renderer/thread_util.h",
    "libcef/renderer/v8_impl.cc",
    "libcef/renderer/v8_impl.h",
-    "libcef/renderer/webkit_glue.cc",
-    "libcef/renderer/webkit_glue.h",
    "libcef/utility/content_utility_client.cc",
    "libcef/utility/content_utility_client.h",

@@ -570,10 +651,6 @@ static_library("libcef_static") {
    # with enable_print_preview=0.
    "//chrome/renderer/pepper/chrome_pdf_print_client.cc",
    "//chrome/renderer/pepper/chrome_pdf_print_client.h",
-
-    # Part of //components/prefs:test_support which is testingonly.
-    "//components/prefs/testing_pref_store.cc",
-    "//components/prefs/testing_pref_store.h",
  ]

  configs += [
@@ -582,9 +659,6 @@ static_library("libcef_static") {

    # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
    "//build/config/compiler:no_size_t_to_int_warning",
-
-    # Blink-internal include paths.
-    "//third_party/WebKit/Source/core:core_include_dirs",
  ]

  public_configs = [
@@ -592,10 +666,8 @@ static_library("libcef_static") {
  ]

  include_dirs = [
-    # Blink code uses paths relative to these directories. We need them because
-    # we include Blink headers.
-    "//third_party/WebKit/public/platform",
-    "//third_party/WebKit/public/web",
+    # Crashpad code uses paths relative to this directory.
+    "//third_party/crashpad/crashpad",
  ]

  public_deps = [
@@ -633,6 +705,7 @@ static_library("libcef_static") {
    "//components/keyed_service/content:content",
    "//components/keyed_service/core:core",
    "//components/navigation_interception",
+    "//components/network_session_configurator/common",
    "//components/pdf/browser",
    "//components/pdf/renderer",
    "//components/plugins/renderer",
@@ -640,6 +713,9 @@ static_library("libcef_static") {
    "//components/printing/browser",
    "//components/printing/common",
    "//components/printing/renderer",
+    "//components/printing/service:pdf_compositor_manifest",
+    "//components/printing/service/public/cpp:factory",
+    "//components/printing/service/public/interfaces",
    "//components/proxy_config",
    "//components/ssl_config",
    "//components/update_client",
@@ -649,9 +725,11 @@ static_library("libcef_static") {
    "//components/visitedlink/browser",
    "//components/visitedlink/common",
    "//components/visitedlink/renderer",
+    "//components/viz/service",
    "//components/web_cache/renderer",
    "//content/public/app:both",
    "//content/public/browser",
+    "//content/public/child",
    "//content/public/common",
    "//content/public/gpu",
    "//content/public/renderer",
@@ -672,12 +750,17 @@ static_library("libcef_static") {
    "//media/blink",
    "//net",
    "//net:net_browser_services",
+    "//net:net_utility_services",
    "//net:net_with_v8",
    "//pdf",
    "//ppapi/features",
    "//printing/features",
+    "//services/service_manager/embedder",
+    "//services/service_manager/public/interfaces",
+    "//services/service_manager/runner/common",
    "//skia",
    "//storage/browser",
+    "//third_party/brotli:dec",
    "//third_party/cld",
    "//third_party/hunspell",
    "//third_party/leveldatabase",
@@ -734,6 +817,14 @@ static_library("libcef_static") {
    deps += [
      "//chrome_elf",
    ]
+
+    if (is_component_build) {
+      deps += [ "//content:sandbox_helper_win" ]
+    }
+
+    libs = [
+      "comctl32.lib",
+    ]
  }

  if (is_linux) {
@@ -752,8 +843,8 @@ static_library("libcef_static") {
    ]

    deps += [
-      "//build/linux:fontconfig",
-      "//third_party/freetype2",
+      "//build/config/freetype",
+      "//third_party/fontconfig",
    ]
  }

@@ -868,6 +959,7 @@ static_library("libcef_static") {
      "//ui/events",
      "//ui/strings",
      "//ui/wm",
+      "//ui/wm/public",
    ]

    if (toolkit_views) {
@@ -1023,7 +1115,7 @@ repack("pak_devtools") {
  # Each input pak file should also have a deps line for completeness.
  # Add associated .h files in the make_pack_header("resources") target.
  sources = [
-    "$root_gen_dir/blink/devtools_resources.pak",
+    "$root_gen_dir/content/browser/devtools/devtools_resources.pak",
  ]

  # Use public_deps so that generated grit headers are discoverable from
@@ -1161,7 +1253,6 @@ template("make_pack_header") {
 make_pack_header("resources") {
  header = "$root_out_dir/includes/include/cef_pack_resources.h"
  inputs = [
-    "$root_gen_dir/blink/grit/devtools_resources.h",
    "$root_gen_dir/blink/public/resources/grit/blink_image_resources.h",
    "$root_gen_dir/blink/public/resources/grit/blink_resources.h",
    "$root_gen_dir/cef/grit/cef_resources.h",
@@ -1171,6 +1262,7 @@ make_pack_header("resources") {
    "$root_gen_dir/chrome/grit/net_internals_resources.h",
    "$root_gen_dir/chrome/grit/renderer_resources.h",
    "$root_gen_dir/components/grit/components_resources.h",
+    "$root_gen_dir/content/browser/devtools/grit/devtools_resources.h",
    "$root_gen_dir/content/browser/tracing/grit/tracing_resources.h",
    "$root_gen_dir/content/grit/content_resources.h",
    "$root_gen_dir/extensions/grit/extensions_browser_resources.h",
@@ -1710,7 +1802,7 @@ if (is_mac) {
    deps = [
      ":libcef",
      ":libcef_dll_wrapper",
-      "//build/config/sanitizers:deps",
+      "//build/config:exe_and_shlib_deps",
    ]

    if (is_win) {
@@ -1737,11 +1829,12 @@ if (is_mac) {

      libs = [
        "comctl32.lib",
-        "shlwapi.lib",
-        "rpcrt4.lib",
-        "opengl32.lib",
        "glu32.lib",
        "imm32.lib",
+        "oleacc.lib",
+        "opengl32.lib",
+        "rpcrt4.lib",
+        "shlwapi.lib",
      ]
    }

@@ -1785,7 +1878,7 @@ if (is_mac) {
    deps = [
      ":libcef",
      ":libcef_dll_wrapper",
-      "//build/config/sanitizers:deps",
+      "//build/config:exe_and_shlib_deps",
    ]

    if (is_win) {
@@ -1854,7 +1947,7 @@ if (is_mac) {
    deps = [
      ":libcef",
      ":libcef_dll_wrapper",
-      "//build/config/sanitizers:deps",
+      "//build/config:exe_and_shlib_deps",
      "//testing/gtest",
    ]

--- a/CHROMIUM_BUILD_COMPATIBILITY.txt
+++ b/CHROMIUM_BUILD_COMPATIBILITY.txt
@@ -7,5 +7,5 @@
 # https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding

 {
-  'chromium_checkout': 'refs/tags/56.0.2924.76',
+  'chromium_checkout': 'refs/tags/61.0.3163.91',
 }
--- a/CMakeLists.txt.in
+++ b/CMakeLists.txt.in
@@ -48,13 +48,13 @@
 #     libgtkglext1-dev  (required by the cefclient target only)
 #
 # - Mac OS X requirements:
-#   Xcode 5 or newer building on Mac OS X 10.9 (Mavericks) or newer. Xcode 7.2
-#   and OS X 10.11 are recommended. The Xcode command-line tools must also be
+#   Xcode 5 or newer building on Mac OS X 10.9 (Mavericks) or newer. Xcode 8.3
+#   and OS X 10.12 are recommended. The Xcode command-line tools must also be
 #   installed. Only 64-bit builds are supported on OS X.
 #
 # - Windows requirements:
 #   Visual Studio 2010 or newer building on Windows 7 or newer. Visual Studio
-#   2015 Update 2 and Windows 10 64-bit are recommended.
+#   2015 Update 3 and Windows 10 64-bit are recommended.
 #
 # BUILD EXAMPLES
 #
--- a/README.md
+++ b/README.md
@@ -47,7 +47,8 @@ The base CEF framework includes support for the C and C++ programming languages.
 * .Net/Mono (CEF3) - https://bitbucket.org/xilium/xilium.cefglue
 * .Net (CEF3) - https://bitbucket.org/chromiumfx/chromiumfx
 * Delphi (CEF1) - http://code.google.com/p/delphichromiumembedded/
-* Delphi (CEF3) - http://code.google.com/p/dcef3/
+* Delphi (CEF3) - https://github.com/hgourvest/dcef3
+* Delphi (CEF3) - https://github.com/salvadordf/CEF4Delphi
 * Go - https://github.com/CzarekTomczak/cef2go
 * Java - https://bitbucket.org/chromiumembedded/java-cef
 * Java - http://code.google.com/p/javacef/
--- a/cef_paths.gypi
+++ b/cef_paths.gypi
@@ -8,10 +8,13 @@
 # by hand. See the translator.README.txt file in the tools directory for
 # more information.
 #
+# $hash=20588ad142633d169a929c7631888e287ab66b9a$
+#

 {
  'variables': {
    'autogen_cpp_includes': [
+      'include/cef_accessibility_handler.h',
      'include/cef_app.h',
      'include/cef_auth_callback.h',
      'include/cef_browser.h',
@@ -77,6 +80,7 @@
      'include/cef_x509_certificate.h',
      'include/cef_xml_reader.h',
      'include/cef_zip_reader.h',
+      'include/test/cef_test_helpers.h',
      'include/test/cef_translator_test.h',
      'include/views/cef_box_layout.h',
      'include/views/cef_browser_view.h',
@@ -100,6 +104,7 @@
      'include/views/cef_window_delegate.h',
    ],
    'autogen_capi_includes': [
+      'include/capi/cef_accessibility_handler_capi.h',
      'include/capi/cef_app_capi.h',
      'include/capi/cef_auth_callback_capi.h',
      'include/capi/cef_browser_capi.h',
@@ -165,6 +170,7 @@
      'include/capi/cef_x509_certificate_capi.h',
      'include/capi/cef_xml_reader_capi.h',
      'include/capi/cef_zip_reader_capi.h',
+      'include/capi/test/cef_test_helpers_capi.h',
      'include/capi/test/cef_translator_test_capi.h',
      'include/capi/views/cef_box_layout_capi.h',
      'include/capi/views/cef_browser_view_capi.h',
@@ -188,6 +194,8 @@
      'include/capi/views/cef_window_delegate_capi.h',
    ],
    'autogen_library_side': [
+      'libcef_dll/ctocpp/accessibility_handler_ctocpp.cc',
+      'libcef_dll/ctocpp/accessibility_handler_ctocpp.h',
      'libcef_dll/ctocpp/app_ctocpp.cc',
      'libcef_dll/ctocpp/app_ctocpp.h',
      'libcef_dll/cpptoc/auth_callback_cpptoc.cc',
@@ -390,16 +398,26 @@
      'libcef_dll/cpptoc/thread_cpptoc.h',
      'libcef_dll/cpptoc/test/translator_test_cpptoc.cc',
      'libcef_dll/cpptoc/test/translator_test_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_handler_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_handler_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_handler_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_handler_child_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_object_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_object_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_object_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_object_child_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_object_child_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_object_child_child_cpptoc.h',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_client_child_ctocpp.h',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_library_child_child_cpptoc.h',
+      'libcef_dll/ctocpp/test/translator_test_scoped_client_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_scoped_client_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_scoped_client_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_scoped_client_child_ctocpp.h',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_scoped_library_child_child_cpptoc.h',
      'libcef_dll/cpptoc/urlrequest_cpptoc.cc',
      'libcef_dll/cpptoc/urlrequest_cpptoc.h',
      'libcef_dll/ctocpp/urlrequest_client_ctocpp.cc',
@@ -450,6 +468,8 @@
      'libcef_dll/cpptoc/zip_reader_cpptoc.h',
    ],
    'autogen_client_side': [
+      'libcef_dll/cpptoc/accessibility_handler_cpptoc.cc',
+      'libcef_dll/cpptoc/accessibility_handler_cpptoc.h',
      'libcef_dll/cpptoc/app_cpptoc.cc',
      'libcef_dll/cpptoc/app_cpptoc.h',
      'libcef_dll/ctocpp/auth_callback_ctocpp.cc',
@@ -652,16 +672,26 @@
      'libcef_dll/ctocpp/thread_ctocpp.h',
      'libcef_dll/ctocpp/test/translator_test_ctocpp.cc',
      'libcef_dll/ctocpp/test/translator_test_ctocpp.h',
-      'libcef_dll/cpptoc/test/translator_test_handler_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_handler_cpptoc.h',
-      'libcef_dll/cpptoc/test/translator_test_handler_child_cpptoc.cc',
-      'libcef_dll/cpptoc/test/translator_test_handler_child_cpptoc.h',
-      'libcef_dll/ctocpp/test/translator_test_object_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_object_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_object_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_object_child_ctocpp.h',
-      'libcef_dll/ctocpp/test/translator_test_object_child_child_ctocpp.cc',
-      'libcef_dll/ctocpp/test/translator_test_object_child_child_ctocpp.h',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.h',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_child_ctocpp.h',
+      'libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.h',
+      'libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.cc',
+      'libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.h',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.h',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_child_ctocpp.cc',
+      'libcef_dll/ctocpp/test/translator_test_scoped_library_child_child_ctocpp.h',
      'libcef_dll/ctocpp/urlrequest_ctocpp.cc',
      'libcef_dll/ctocpp/urlrequest_ctocpp.h',
      'libcef_dll/cpptoc/urlrequest_client_cpptoc.cc',
--- a/cef_paths2.gypi
+++ b/cef_paths2.gypi
@@ -88,12 +88,17 @@
      'include/internal/cef_types_linux.h',
    ],
    'libcef_sources_common': [
-      'libcef_dll/cpptoc/cpptoc.h',
-      'libcef_dll/ctocpp/base_ctocpp.cc',
-      'libcef_dll/ctocpp/base_ctocpp.h',
-      'libcef_dll/ctocpp/ctocpp.h',
+      'libcef_dll/cpptoc/cpptoc_ref_counted.h',
+      'libcef_dll/cpptoc/cpptoc_scoped.h',
+      'libcef_dll/ctocpp/base_ref_counted_ctocpp.cc',
+      'libcef_dll/ctocpp/base_ref_counted_ctocpp.h',
+      'libcef_dll/ctocpp/base_scoped_ctocpp.cc',
+      'libcef_dll/ctocpp/base_scoped_ctocpp.h',
+      'libcef_dll/ctocpp/ctocpp_ref_counted.h',
+      'libcef_dll/ctocpp/ctocpp_scoped.h',
      'libcef_dll/libcef_dll.cc',
      'libcef_dll/libcef_dll2.cc',
+      'libcef_dll/ptr_util.h',
      'libcef_dll/resource.h',
      'libcef_dll/transfer_util.cc',
      'libcef_dll/transfer_util.h',
@@ -114,10 +119,15 @@
      'libcef_dll/base/cef_weak_ptr.cc',
    ],
    'libcef_dll_wrapper_sources_common': [
-      'libcef_dll/cpptoc/base_cpptoc.cc',
-      'libcef_dll/cpptoc/base_cpptoc.h',
-      'libcef_dll/cpptoc/cpptoc.h',
-      'libcef_dll/ctocpp/ctocpp.h',
+      'libcef_dll/cpptoc/base_ref_counted_cpptoc.cc',
+      'libcef_dll/cpptoc/base_ref_counted_cpptoc.h',
+      'libcef_dll/cpptoc/base_scoped_cpptoc.cc',
+      'libcef_dll/cpptoc/base_scoped_cpptoc.h',
+      'libcef_dll/cpptoc/cpptoc_ref_counted.h',
+      '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/transfer_util.cc',
      'libcef_dll/transfer_util.h',
      'libcef_dll/wrapper_types.h',
@@ -276,6 +286,11 @@
      'tests/cefclient/browser/main_context_impl_win.cc',
      'tests/cefclient/browser/main_message_loop_multithreaded_win.cc',
      'tests/cefclient/browser/main_message_loop_multithreaded_win.h',
+      'tests/cefclient/browser/osr_accessibility_helper.cc',
+      'tests/cefclient/browser/osr_accessibility_helper.h',
+      'tests/cefclient/browser/osr_accessibility_node.cc',
+      'tests/cefclient/browser/osr_accessibility_node.h',
+      'tests/cefclient/browser/osr_accessibility_node_win.cc',
      'tests/cefclient/browser/osr_dragdrop_win.cc',
      'tests/cefclient/browser/osr_dragdrop_win.h',
      'tests/cefclient/browser/osr_ime_handler_win.cc',
@@ -289,6 +304,10 @@
      'tests/cefclient/browser/root_window_win.h',
      'tests/cefclient/browser/temp_window_win.cc',
      'tests/cefclient/browser/temp_window_win.h',
+      'tests/cefclient/browser/views_menu_bar.cc',
+      'tests/cefclient/browser/views_menu_bar.h',
+      'tests/cefclient/browser/views_style.cc',
+      'tests/cefclient/browser/views_style.h',
      'tests/cefclient/browser/views_window.cc',
      'tests/cefclient/browser/views_window.h',
      'tests/cefclient/browser/window_test_runner_views.cc',
@@ -307,6 +326,11 @@
      'tests/cefclient/browser/browser_window_std_mac.h',
      'tests/cefclient/browser/browser_window_std_mac.mm',
      'tests/cefclient/browser/main_context_impl_posix.cc',
+      'tests/cefclient/browser/osr_accessibility_helper.cc',
+      'tests/cefclient/browser/osr_accessibility_helper.h',
+      'tests/cefclient/browser/osr_accessibility_node.cc',
+      'tests/cefclient/browser/osr_accessibility_node.h',
+      'tests/cefclient/browser/osr_accessibility_node_mac.mm',
      'tests/cefclient/browser/root_window_mac.h',
      'tests/cefclient/browser/root_window_mac.mm',
      'tests/cefclient/browser/temp_window_mac.h',
@@ -340,6 +364,10 @@
      'tests/cefclient/browser/root_window_views.h',
      'tests/cefclient/browser/temp_window_x11.cc',
      'tests/cefclient/browser/temp_window_x11.h',
+      'tests/cefclient/browser/views_menu_bar.cc',
+      'tests/cefclient/browser/views_menu_bar.h',
+      'tests/cefclient/browser/views_style.cc',
+      'tests/cefclient/browser/views_style.h',
      'tests/cefclient/browser/views_window.cc',
      'tests/cefclient/browser/views_window.h',
      'tests/cefclient/browser/window_test_runner_gtk.cc',
@@ -402,6 +430,8 @@
      'tests/ceftests/message_router_unittest.cc',
      '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/preference_unittest.cc',
--- a/cmake/cef_macros.cmake.in
+++ b/cmake/cef_macros.cmake.in
@@ -19,7 +19,7 @@ macro(PRINT_CEF_CONFIG)
  message(STATUS "Platform:                     ${CMAKE_SYSTEM_NAME}")
  message(STATUS "Project architecture:         ${PROJECT_ARCH}")

-  if(${CMAKE_GENERATOR} STREQUAL "Ninja" OR ${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
+  if(GEN_NINJA OR GEN_MAKEFILES)
    message(STATUS "Build type:                   ${CMAKE_BUILD_TYPE}")
  endif()

@@ -81,8 +81,7 @@ endmacro()

 # Determine the target output directory based on platform and generator.
 macro(SET_CEF_TARGET_OUT_DIR)
-  if(${CMAKE_GENERATOR} STREQUAL "Ninja" OR
-     ${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
+  if(GEN_NINJA OR GEN_MAKEFILES)
    # By default Ninja and Make builds don't create a subdirectory named after
    # the configuration.
    set(CEF_TARGET_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}")
@@ -276,17 +275,17 @@ endmacro()
 # SET_EXECUTABLE_TARGET_PROPERTIES() instead of calling this macro directly.
 macro(SET_COMMON_TARGET_PROPERTIES target)
  # Compile flags.
-  target_compile_options(${target} PUBLIC ${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS})
-  target_compile_options(${target} PUBLIC $<$<CONFIG:Debug>:${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}>)
-  target_compile_options(${target} PUBLIC $<$<CONFIG:Release>:${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}>)
+  target_compile_options(${target} PRIVATE ${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS})
+  target_compile_options(${target} PRIVATE $<$<CONFIG:Debug>:${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}>)
+  target_compile_options(${target} PRIVATE $<$<CONFIG:Release>:${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}>)

  # Compile definitions.
-  target_compile_definitions(${target} PUBLIC ${CEF_COMPILER_DEFINES})
-  target_compile_definitions(${target} PUBLIC $<$<CONFIG:Debug>:${CEF_COMPILER_DEFINES_DEBUG}>)
-  target_compile_definitions(${target} PUBLIC $<$<CONFIG:Release>:${CEF_COMPILER_DEFINES_RELEASE}>)
+  target_compile_definitions(${target} PRIVATE ${CEF_COMPILER_DEFINES})
+  target_compile_definitions(${target} PRIVATE $<$<CONFIG:Debug>:${CEF_COMPILER_DEFINES_DEBUG}>)
+  target_compile_definitions(${target} PRIVATE $<$<CONFIG:Release>:${CEF_COMPILER_DEFINES_RELEASE}>)

  # Include directories.
-  target_include_directories(${target} PUBLIC ${CEF_INCLUDE_PATH})
+  target_include_directories(${target} PRIVATE ${CEF_INCLUDE_PATH})

  # Linker flags.
  if(CEF_LINKER_FLAGS)
--- a/cmake/cef_variables.cmake.in
+++ b/cmake/cef_variables.cmake.in
@@ -37,9 +37,14 @@ if(NOT DEFINED PROJECT_ARCH)
  endif()
 endif()

+if(${CMAKE_GENERATOR} STREQUAL "Ninja")
+  set(GEN_NINJA 1)
+elseif(${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
+  set(GEN_MAKEFILES 1)
+endif()
+
 # Determine the build type.
-if(NOT CMAKE_BUILD_TYPE AND
-   (${CMAKE_GENERATOR} STREQUAL "Ninja" OR ${CMAKE_GENERATOR} STREQUAL "Unix Makefiles"))
+if(NOT CMAKE_BUILD_TYPE AND (GEN_NINJA OR GEN_MAKEFILES))
  # CMAKE_BUILD_TYPE should be specified when using Ninja or Unix Makefiles.
  set(CMAKE_BUILD_TYPE Release)
  message(WARNING "No CMAKE_BUILD_TYPE value selected, using ${CMAKE_BUILD_TYPE}")
@@ -215,7 +220,7 @@ endif()

 if(OS_MACOSX)
  # Platform-specific compiler/linker flags.
-  # See also Xcode target properties in macros.cmake.
+  # See also Xcode target properties in cef_macros.cmake.
  set(CEF_LIBTYPE SHARED)
  list(APPEND CEF_COMPILER_FLAGS
    -fno-strict-aliasing            # Avoid assumptions regarding non-aliasing of objects of different types
@@ -259,6 +264,15 @@ if(OS_MACOSX)
    -Wl,-dead_strip                 # Strip dead code
    )

+  include(CheckCXXCompilerFlag)
+
+  CHECK_CXX_COMPILER_FLAG(-Wno-undefined-var-template COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
+  if(COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
+    list(APPEND CEF_CXX_COMPILER_FLAGS
+      -Wno-undefined-var-template   # Don't warn about potentially uninstantiated static members
+      )
+  endif()
+
  # Standard libraries.
  set(CEF_STANDARD_LIBS
    -lpthread
@@ -305,22 +319,21 @@ endif()
 #

 if(OS_WINDOWS)
-  # Configure use of the sandbox.
-  option(USE_SANDBOX "Enable or disable use of the sandbox." ON)
-  if(USE_SANDBOX AND NOT MSVC_VERSION EQUAL 1900)
-    # The cef_sandbox.lib static library is currently built with VS2015. It will
-    # not link successfully with other VS versions.
-    set(USE_SANDBOX OFF)
+  if (GEN_NINJA)
+    # When using the Ninja generator clear the CMake defaults to avoid excessive
+    # console warnings (see issue #2120).
+    set(CMAKE_CXX_FLAGS "")
+    set(CMAKE_CXX_FLAGS_DEBUG "")
+    set(CMAKE_CXX_FLAGS_RELEASE "")
  endif()

-  # Configure use of official build compiler settings.
-  # When using an official build the "Debug" build is actually a Release build
-  # with DCHECKs enabled. In order to link the sandbox the Debug build must
-  # be configured with some Release-related compiler settings.
-  option(USE_OFFICIAL_BUILD_SANDBOX "Enable or disable use of an official build sandbox." ON)
-  if(NOT USE_SANDBOX)
-    # Don't need official build settings when the sandbox is off.
-    set(USE_OFFICIAL_BUILD_SANDBOX OFF)
+  # Configure use of the sandbox.
+  option(USE_SANDBOX "Enable or disable use of the sandbox." ON)
+  if(USE_SANDBOX AND NOT MSVC_VERSION EQUAL 1900 AND NOT MSVC_VERSION EQUAL 1910)
+    # The cef_sandbox.lib static library is currently built with VS2015, which
+    # is compatible with VS2015 and VS2017. It will not link successfully with
+    # other VS versions.
+    set(USE_SANDBOX OFF)
  endif()

  # Consumers who run into LNK4099 warnings can pass /Z7 instead (see issue #385).
@@ -344,22 +357,11 @@ if(OS_WINDOWS)
    /wd4996       # Ignore "function or variable may be unsafe" warning
    ${CEF_DEBUG_INFO_FLAG}
    )
-  if(USE_OFFICIAL_BUILD_SANDBOX)
-    # CMake adds /RTC1, /D"_DEBUG" and a few other values by default for Debug
-    # builds. We can't link the sandbox with those values so clear the CMake
-    # defaults here.
-    set(CMAKE_CXX_FLAGS_DEBUG "")
-
-    list(APPEND CEF_COMPILER_FLAGS_DEBUG
-      /MT           # Multithreaded release runtime
-      )
-  else()
  list(APPEND CEF_COMPILER_FLAGS_DEBUG
    /MTd          # Multithreaded debug runtime
    /RTC1         # Disable optimizations
    /Od           # Enable basic run-time checks
    )
-  endif()
  list(APPEND CEF_COMPILER_FLAGS_RELEASE
    /MT           # Multithreaded release runtime
    /O2           # Optimize for maximum speed
@@ -381,12 +383,6 @@ if(OS_WINDOWS)
    WIN32_LEAN_AND_MEAN               # Exclude less common API declarations
    _HAS_EXCEPTIONS=0                 # Disable exceptions
    )
-  if(USE_OFFICIAL_BUILD_SANDBOX)
-    list(APPEND CEF_COMPILER_DEFINES_DEBUG
-      NDEBUG _NDEBUG                    # Not a debug build
-      DCHECK_ALWAYS_ON=1                # DCHECKs are enabled
-      )
-  endif()
  list(APPEND CEF_COMPILER_DEFINES_RELEASE
    NDEBUG _NDEBUG                    # Not a debug build
    )
@@ -454,10 +450,26 @@ if(OS_WINDOWS)
  # Configure use of ATL.
  option(USE_ATL "Enable or disable use of ATL." ON)
  if(USE_ATL)
+    # Locate the atlmfc directory if it exists. It may be at any depth inside
+    # the VC directory. The cl.exe path returned by CMAKE_CXX_COMPILER may also
+    # be at different depths depending on the toolchain version
+    # (e.g. "VC/bin/cl.exe", "VC/bin/amd64_x86/cl.exe",
+    # "VC/Tools/MSVC/14.10.25017/bin/HostX86/x86/cl.exe", etc).
+    set(HAS_ATLMFC 0)
+    get_filename_component(VC_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)
+    get_filename_component(VC_DIR_NAME ${VC_DIR} NAME)
+    while(NOT ${VC_DIR_NAME} STREQUAL "VC")
+      get_filename_component(VC_DIR ${VC_DIR} DIRECTORY)
+      if(IS_DIRECTORY "${VC_DIR}/atlmfc")
+        set(HAS_ATLMFC 1)
+        break()
+      endif()
+      get_filename_component(VC_DIR_NAME ${VC_DIR} NAME)
+    endwhile()
+
    # Determine if the Visual Studio install supports ATL.
-    get_filename_component(VC_BIN_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)
-    get_filename_component(VC_DIR ${VC_BIN_DIR} DIRECTORY)
-    if(NOT IS_DIRECTORY "${VC_DIR}/atlmfc")
+    if(NOT HAS_ATLMFC)
+      message(WARNING "ATL is not supported by your VC installation.")
      set(USE_ATL OFF)
    endif()
  endif()
--- a/include/base/cef_atomic_ref_count.h
+++ b/include/base/cef_atomic_ref_count.h
@@ -39,14 +39,49 @@
 #define CEF_INCLUDE_BASE_CEF_ATOMIC_REF_COUNT_H_
 #pragma once

-#if defined(BASE_ATOMIC_REF_COUNT_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)
+#if defined(USING_CHROMIUM_INCLUDES)
 // 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
@@ -58,6 +93,10 @@
 #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;
--- a/include/base/cef_atomicops.h
+++ b/include/base/cef_atomicops.h
@@ -122,8 +122,7 @@ Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
 // *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);
+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,
--- a/include/base/cef_basictypes.h
+++ b/include/base/cef_basictypes.h
@@ -43,11 +43,11 @@
 // On Mac OS X, |long long| is used for 64-bit types for compatibility with
 // <inttypes.h> format macros even in the LP64 model.
 #if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
-typedef long                int64;  // NOLINT(runtime/int)
-typedef unsigned long       uint64;  // NOLINT(runtime/int)
+typedef long int64;
+typedef unsigned long uint64;
 #else
-typedef long long           int64;  // NOLINT(runtime/int)
-typedef unsigned long long  uint64;  // NOLINT(runtime/int)
+typedef long long int64;
+typedef unsigned long long uint64;
 #endif

 // TODO: Remove these type guards.  These are to avoid conflicts with
--- a/include/base/cef_bind.h
+++ b/include/base/cef_bind.h
@@ -89,34 +89,32 @@
 namespace base {

 template <typename Functor>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
-        void()>
-            ::UnboundRunType>
+    void()>::UnboundRunType>
 Bind(Functor functor) {
  // Typedefs for how to store and run the functor.
-  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  typedef
+      typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;

-
  return Callback<typename BindState::UnboundRunType>(
      new BindState(cef_internal::MakeRunnable(functor)));
 }

 template <typename Functor, typename P1>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
-        void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
-            ::UnboundRunType>
+    void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>::
+                   UnboundRunType>
 Bind(Functor functor, const P1& p1) {
  // Typedefs for how to store and run the functor.
-  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  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
@@ -138,32 +136,32 @@ Bind(Functor functor, const P1& p1) {
  // 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 ||
+  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;
-
+  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>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-            typename cef_internal::CallbackParamTraits<P2>::StorageType)>
-            ::UnboundRunType>
+         typename cef_internal::CallbackParamTraits<P2>::StorageType)>::
+                   UnboundRunType>
 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>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  // Use RunnableType::RunType instead of RunType above because our
@@ -186,8 +184,7 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
  // 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 ||
+  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 ||
@@ -195,27 +192,28 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
                 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,
+  typedef cef_internal::BindState<
+      RunnableType, RunType,
      void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
-      typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState;
-
+           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>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
         typename cef_internal::CallbackParamTraits<P2>::StorageType,
-            typename cef_internal::CallbackParamTraits<P3>::StorageType)>
-            ::UnboundRunType>
+         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>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  // Use RunnableType::RunType instead of RunType above because our
@@ -239,8 +237,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
  // 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 ||
+  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 ||
@@ -250,29 +247,30 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
                 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,
+  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;
-
+           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>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::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)>
-            ::UnboundRunType>
+         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>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  // Use RunnableType::RunType instead of RunType above because our
@@ -297,8 +295,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
  // 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 ||
+  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 ||
@@ -310,33 +307,42 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
                 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,
+  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;
-
+           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, typename P1, typename P2, typename P3, typename P4,
+template <typename Functor,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
          typename P5>
-base::Callback<
-    typename cef_internal::BindState<
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::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)>
-            ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
+         typename cef_internal::CallbackParamTraits<P5>::StorageType)>::
+                   UnboundRunType>
+Bind(Functor functor,
+     const P1& p1,
+     const P2& p2,
+     const P3& p3,
+     const P4& p4,
     const P5& p5) {
  // Typedefs for how to store and run the functor.
-  typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
+  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
@@ -362,8 +368,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
  // 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 ||
+  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 ||
@@ -377,22 +382,27 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
                 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,
+  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;
-
+           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, typename P1, typename P2, typename P3, typename P4,
-    typename P5, typename P6>
-base::Callback<
-    typename cef_internal::BindState<
+template <typename Functor,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename P5,
+          typename P6>
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@@ -400,12 +410,18 @@ base::Callback<
         typename cef_internal::CallbackParamTraits<P3>::StorageType,
         typename cef_internal::CallbackParamTraits<P4>::StorageType,
         typename cef_internal::CallbackParamTraits<P5>::StorageType,
-            typename cef_internal::CallbackParamTraits<P6>::StorageType)>
-            ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
-    const P5& p5, const P6& p6) {
+         typename cef_internal::CallbackParamTraits<P6>::StorageType)>::
+                   UnboundRunType>
+Bind(Functor functor,
+     const P1& p1,
+     const P2& p2,
+     const P3& p3,
+     const P4& p4,
+     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>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  // Use RunnableType::RunType instead of RunType above because our
@@ -432,8 +448,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
  // 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 ||
+  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 ||
@@ -449,23 +464,29 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
                 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,
+  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;
+           typename cef_internal::CallbackParamTraits<P6>::StorageType)>
+      BindState;

-
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
+  return Callback<typename BindState::UnboundRunType>(new BindState(
+      cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
 }

-template <typename Functor, typename P1, typename P2, typename P3, typename P4,
-    typename P5, typename P6, typename P7>
-base::Callback<
-    typename cef_internal::BindState<
+template <typename Functor,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename P5,
+          typename P6,
+          typename P7>
+base::Callback<typename cef_internal::BindState<
    typename cef_internal::FunctorTraits<Functor>::RunnableType,
    typename cef_internal::FunctorTraits<Functor>::RunType,
    void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@@ -474,12 +495,19 @@ base::Callback<
         typename cef_internal::CallbackParamTraits<P4>::StorageType,
         typename cef_internal::CallbackParamTraits<P5>::StorageType,
         typename cef_internal::CallbackParamTraits<P6>::StorageType,
-            typename cef_internal::CallbackParamTraits<P7>::StorageType)>
-            ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
-    const P5& p5, const P6& p6, const P7& p7) {
+         typename cef_internal::CallbackParamTraits<P7>::StorageType)>::
+                   UnboundRunType>
+Bind(Functor functor,
+     const P1& p1,
+     const P2& p2,
+     const P3& p3,
+     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>::RunnableType RunnableType;
  typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;

  // Use RunnableType::RunType instead of RunType above because our
@@ -507,8 +535,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
  // 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 ||
+  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 ||
@@ -526,19 +553,19 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
                 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,
+  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;
+           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));
+  return Callback<typename BindState::UnboundRunType>(new BindState(
+      cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, p7));
 }

 }  // namespace base
--- a/include/base/cef_bind_helpers.h
+++ b/include/base/cef_bind_helpers.h
@@ -276,13 +276,13 @@ class SupportsAddRefAndRelease {
 #pragma warning(push)
 #pragma warning(disable : 4624)
 #endif
-  struct Base : public T, public BaseMixin {
-  };
+  struct Base : public T, public BaseMixin {};
 #if defined(OS_WIN)
 #pragma warning(pop)
 #endif

-  template <void(BaseMixin::*)(void)> struct Helper {};
+  template <void (BaseMixin::*)(void)>
+  struct Helper {};

  template <typename C>
  static No& Check(Helper<&C::AddRef>*);
@@ -297,22 +297,18 @@ class SupportsAddRefAndRelease {
 // Helpers to assert that arguments of a recounted type are bound with a
 // scoped_refptr.
 template <bool IsClasstype, typename T>
-struct UnsafeBindtoRefCountedArgHelper : false_type {
-};
+struct UnsafeBindtoRefCountedArgHelper : false_type {};

 template <typename T>
 struct UnsafeBindtoRefCountedArgHelper<true, T>
-    : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
-};
+    : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {};

 template <typename T>
-struct UnsafeBindtoRefCountedArg : false_type {
-};
+struct UnsafeBindtoRefCountedArg : false_type {};

 template <typename T>
 struct UnsafeBindtoRefCountedArg<T*>
-    : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
-};
+    : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {};

 template <typename T>
 class HasIsMethodTag {
@@ -334,6 +330,7 @@ class UnretainedWrapper {
 public:
  explicit UnretainedWrapper(T* o) : ptr_(o) {}
  T* get() const { return ptr_; }
+
 private:
  T* ptr_;
 };
@@ -343,6 +340,7 @@ class ConstRefWrapper {
 public:
  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
  const T& get() const { return *ptr_; }
+
 private:
  const T* ptr_;
 };
@@ -409,8 +407,7 @@ 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()) {
-  }
+      : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {}
  T Pass() const {
    CHECK(is_valid_);
    is_valid_ = false;
@@ -460,17 +457,13 @@ struct UnwrapTraits<WeakPtr<T> > {
 template <typename T>
 struct UnwrapTraits<OwnedWrapper<T>> {
  typedef T* ForwardType;
-  static ForwardType Unwrap(const OwnedWrapper<T>& o) {
-    return o.get();
-  }
+  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();
-  }
+  static T Unwrap(PassedWrapper<T>& o) { return o.Pass(); }
 };

 // Utility for handling different refcounting semantics in the Bind()
@@ -567,8 +560,8 @@ static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
 }

 template <typename T>
-static inline cef_internal::IgnoreResultHelper<Callback<T> >
-IgnoreResult(const Callback<T>& data) {
+static inline cef_internal::IgnoreResultHelper<Callback<T>> IgnoreResult(
+    const Callback<T>& data) {
  return cef_internal::IgnoreResultHelper<Callback<T>>(data);
 }

--- a/include/base/cef_build.h
+++ b/include/base/cef_build.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-
 #ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
 #define CEF_INCLUDE_BASE_CEF_BUILD_H_
 #pragma once
@@ -116,12 +115,10 @@
 // Type detection for wchar_t.
 #if defined(OS_WIN)
 #define WCHAR_T_IS_UTF16
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
-    defined(__WCHAR_MAX__) && \
+#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
    (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
 #define WCHAR_T_IS_UTF32
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
-    defined(__WCHAR_MAX__) && \
+#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
    (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
 // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
 // compile in this mode (in particular, Chrome doesn't). This is intended for
@@ -189,4 +186,12 @@
 #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_
--- a/include/base/cef_callback.h
+++ b/include/base/cef_callback.h
@@ -45,9 +45,9 @@
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.

-#include "include/base/internal/cef_callback_internal.h"
 #include "include/base/cef_callback_forward.h"
 #include "include/base/cef_template_util.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.
@@ -412,16 +412,15 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -437,9 +436,7 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
  }

 private:
-  typedef R(*PolymorphicInvoke)(
-      cef_internal::BindStateBase*);
-
+  typedef R (*PolymorphicInvoke)(cef_internal::BindStateBase*);
 };

 template <typename R, typename A1>
@@ -452,16 +449,15 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -480,7 +476,6 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
  typedef R (*PolymorphicInvoke)(
      cef_internal::BindStateBase*,
      typename cef_internal::CallbackParamTraits<A1>::ForwardType);
-
 };

 template <typename R, typename A1, typename A2>
@@ -493,16 +488,15 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -524,7 +518,6 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
      cef_internal::BindStateBase*,
      typename cef_internal::CallbackParamTraits<A1>::ForwardType,
      typename cef_internal::CallbackParamTraits<A2>::ForwardType);
-
 };

 template <typename R, typename A1, typename A2, typename A3>
@@ -537,16 +530,15 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -571,7 +563,6 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
      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>
@@ -584,16 +575,15 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -621,10 +611,13 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
      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,
+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:
@@ -635,16 +628,15 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -660,11 +652,10 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
    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));
+    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:
@@ -675,11 +666,15 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
      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>
+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);
@@ -689,16 +684,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -715,11 +709,10 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
    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),
+    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));
  }

@@ -732,12 +725,18 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
      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 {
+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);

@@ -746,16 +745,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
  // 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)
+  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;
+        &cef_internal::BindState<Runnable, BindRunType,
+                                 BoundArgsType>::InvokerType::Run;
    polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
  }

@@ -773,13 +771,11 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
    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));
+    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:
@@ -792,10 +788,8 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
      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;
--- a/include/base/cef_callback_list.h
+++ b/include/base/cef_callback_list.h
@@ -48,12 +48,12 @@
 #include <list>

 #include "include/base/cef_basictypes.h"
-#include "include/base/cef_callback.h"
-#include "include/base/internal/cef_callback_internal.h"
 #include "include/base/cef_build.h"
+#include "include/base/cef_callback.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_macros.h"
 #include "include/base/cef_scoped_ptr.h"
+#include "include/base/internal/cef_callback_internal.h"

 // OVERVIEW:
 //
@@ -120,9 +120,7 @@ class CallbackListBase {
   public:
    Subscription(CallbackListBase<CallbackType>* list,
                 typename std::list<CallbackType>::iterator iter)
-        : list_(list),
-          iter_(iter) {
-    }
+        : list_(list), iter_(iter) {}

    ~Subscription() {
      if (list_->active_iterator_count_) {
@@ -167,14 +165,12 @@ class CallbackListBase {
  class Iterator {
   public:
    explicit Iterator(CallbackListBase<CallbackType>* list)
-        : list_(list),
-          list_iter_(list_->callbacks_.begin()) {
+        : list_(list), list_iter_(list_->callbacks_.begin()) {
      ++list_->active_iterator_count_;
    }

    Iterator(const Iterator& iter)
-        : list_(iter.list_),
-          list_iter_(iter.list_iter_) {
+        : list_(iter.list_), list_iter_(iter.list_iter_) {
      ++list_->active_iterator_count_;
    }

@@ -210,9 +206,7 @@ class CallbackListBase {

  // Returns an instance of a CallbackListBase::Iterator which can be used
  // to run callbacks.
-  Iterator GetIterator() {
-    return Iterator(this);
-  }
+  Iterator GetIterator() { return Iterator(this); }

  // Compact the list: remove any entries which were NULLed out during
  // iteration.
@@ -242,7 +236,8 @@ class CallbackListBase {

 }  // namespace cef_internal

-template <typename Sig> class CallbackList;
+template <typename Sig>
+class CallbackList;

 template <>
 class CallbackList<void(void)>
@@ -357,7 +352,8 @@ class CallbackList<void(A1, A2, A3, A4)>

 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 cef_internal::CallbackListBase<
+          Callback<void(A1, A2, A3, A4, A5)>> {
 public:
  typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;

@@ -380,11 +376,15 @@ class CallbackList<void(A1, A2, A3, A4, A5)>
  DISALLOW_COPY_AND_ASSIGN(CallbackList);
 };

-template <typename A1, typename A2, typename A3, typename A4, typename A5,
+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 cef_internal::CallbackListBase<
+          Callback<void(A1, A2, A3, A4, A5, A6)>> {
 public:
  typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;

@@ -408,11 +408,16 @@ class CallbackList<void(A1, A2, A3, A4, A5, A6)>
  DISALLOW_COPY_AND_ASSIGN(CallbackList);
 };

-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7>
+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 cef_internal::CallbackListBase<
+          Callback<void(A1, A2, A3, A4, A5, A6, A7)>> {
 public:
  typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;

--- a/include/base/cef_cancelable_callback.h
+++ b/include/base/cef_cancelable_callback.h
@@ -83,8 +83,8 @@
 // updated to match.

 #include "include/base/cef_bind.h"
-#include "include/base/cef_callback.h"
 #include "include/base/cef_build.h"
+#include "include/base/cef_callback.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_macros.h"
 #include "include/base/cef_weak_ptr.h"
@@ -102,8 +102,7 @@ class CancelableCallback<void(void)> {

  // |callback| must not be null.
  explicit CancelableCallback(const base::Callback<void(void)>& callback)
-      : weak_factory_(this),
-        callback_(callback) {
+      : weak_factory_(this), callback_(callback) {
    DCHECK(!callback.is_null());
    InitializeForwarder();
  }
@@ -118,9 +117,7 @@ class CancelableCallback<void(void)> {
  }

  // Returns true if the wrapped callback has been cancelled.
-  bool IsCancelled() const {
-    return callback_.is_null();
-  }
+  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.
@@ -137,14 +134,10 @@ class CancelableCallback<void(void)> {
  }

  // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(void)>& callback() const {
-    return forwarder_;
-  }
+  const base::Callback<void(void)>& callback() const { return forwarder_; }

 private:
-  void Forward() {
-    callback_.Run();
-  }
+  void Forward() { callback_.Run(); }

  // Helper method to bind |forwarder_| using a weak pointer from
  // |weak_factory_|.
@@ -172,8 +165,7 @@ class CancelableCallback<void(A1)> {

  // |callback| must not be null.
  explicit CancelableCallback(const base::Callback<void(A1)>& callback)
-      : weak_factory_(this),
-        callback_(callback) {
+      : weak_factory_(this), callback_(callback) {
    DCHECK(!callback.is_null());
    InitializeForwarder();
  }
@@ -188,9 +180,7 @@ class CancelableCallback<void(A1)> {
  }

  // Returns true if the wrapped callback has been cancelled.
-  bool IsCancelled() const {
-    return callback_.is_null();
-  }
+  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.
@@ -207,14 +197,10 @@ class CancelableCallback<void(A1)> {
  }

  // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(A1)>& callback() const {
-    return forwarder_;
-  }
+  const base::Callback<void(A1)>& callback() const { return forwarder_; }

 private:
-  void Forward(A1 a1) const {
-    callback_.Run(a1);
-  }
+  void Forward(A1 a1) const { callback_.Run(a1); }

  // Helper method to bind |forwarder_| using a weak pointer from
  // |weak_factory_|.
@@ -242,8 +228,7 @@ class CancelableCallback<void(A1, A2)> {

  // |callback| must not be null.
  explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
-      : weak_factory_(this),
-        callback_(callback) {
+      : weak_factory_(this), callback_(callback) {
    DCHECK(!callback.is_null());
    InitializeForwarder();
  }
@@ -258,9 +243,7 @@ class CancelableCallback<void(A1, A2)> {
  }

  // Returns true if the wrapped callback has been cancelled.
-  bool IsCancelled() const {
-    return callback_.is_null();
-  }
+  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.
@@ -277,14 +260,10 @@ class CancelableCallback<void(A1, A2)> {
  }

  // Returns a callback that can be disabled by calling Cancel().
-  const base::Callback<void(A1, A2)>& callback() const {
-    return forwarder_;
-  }
+  const base::Callback<void(A1, A2)>& callback() const { return forwarder_; }

 private:
-  void Forward(A1 a1, A2 a2) const {
-    callback_.Run(a1, a2);
-  }
+  void Forward(A1 a1, A2 a2) const { callback_.Run(a1, a2); }

  // Helper method to bind |forwarder_| using a weak pointer from
  // |weak_factory_|.
--- a/include/base/cef_lock.h
+++ b/include/base/cef_lock.h
@@ -125,9 +125,7 @@ class AutoLock {
 public:
  struct AlreadyAcquired {};

-  explicit AutoLock(Lock& lock) : lock_(lock) {
-    lock_.Acquire();
-  }
+  explicit AutoLock(Lock& lock) : lock_(lock) { lock_.Acquire(); }

  AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
    lock_.AssertAcquired();
@@ -153,9 +151,7 @@ class AutoUnlock {
    lock_.Release();
  }

-  ~AutoUnlock() {
-    lock_.Acquire();
-  }
+  ~AutoUnlock() { lock_.Acquire(); }

 private:
  Lock& lock_;
--- a/include/base/cef_logging.h
+++ b/include/base/cef_logging.h
@@ -158,9 +158,9 @@
 // updated to match.

 #include <cassert>
-#include <string>
 #include <cstring>
 #include <sstream>
+#include <string>

 #include "include/base/cef_build.h"
 #include "include/base/cef_macros.h"
@@ -217,16 +217,11 @@ const LogSeverity LOG_DFATAL = LOG_FATAL;
  cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL, \
                          ##__VA_ARGS__)

-#define COMPACT_GOOGLE_LOG_INFO \
-  COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
-#define COMPACT_GOOGLE_LOG_WARNING \
-  COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
-#define COMPACT_GOOGLE_LOG_ERROR \
-  COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
-#define COMPACT_GOOGLE_LOG_FATAL \
-  COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
-#define COMPACT_GOOGLE_LOG_DFATAL \
-  COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
+#define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
+#define COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
+#define COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)

 #if defined(OS_WIN)
 // wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
@@ -291,11 +286,13 @@ const LogSeverity LOG_0 = LOG_ERROR;
 #if defined(OS_WIN)
 #define VPLOG_STREAM(verbose_level)                                            \
  cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level,       \
-    ::cef::logging::GetLastSystemErrorCode()).stream()
+                                     ::cef::logging::GetLastSystemErrorCode()) \
+      .stream()
 #elif defined(OS_POSIX)
 #define VPLOG_STREAM(verbose_level)                                       \
  cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level,       \
-    ::cef::logging::GetLastSystemErrorCode()).stream()
+                                ::cef::logging::GetLastSystemErrorCode()) \
+      .stream()
 #endif

 #define VPLOG(verbose_level) \
@@ -315,15 +312,16 @@ const LogSeverity LOG_0 = LOG_ERROR;
 #if defined(OS_WIN)
 #define PLOG_STREAM(severity)                                                \
  COMPACT_GOOGLE_LOG_EX_##severity(Win32ErrorLogMessage,                     \
-      ::cef::logging::GetLastSystemErrorCode()).stream()
+                                   ::cef::logging::GetLastSystemErrorCode()) \
+      .stream()
 #elif defined(OS_POSIX)
 #define PLOG_STREAM(severity)                                                \
  COMPACT_GOOGLE_LOG_EX_##severity(ErrnoLogMessage,                          \
-      ::cef::logging::GetLastSystemErrorCode()).stream()
+                                   ::cef::logging::GetLastSystemErrorCode()) \
+      .stream()
 #endif

-#define PLOG(severity)                                          \
-  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
+#define PLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))

 #define PLOG_IF(severity, condition) \
  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
@@ -353,9 +351,8 @@ const LogSeverity LOG_0 = LOG_ERROR;
 // TODO(akalin): Rewrite this so that constructs like if (...)
 // CHECK_EQ(...) else { ... } work properly.
 #define CHECK_OP(name, op, val1, val2)                        \
-  if (std::string* _result =                                    \
-      cef::logging::Check##name##Impl((val1), (val2),                \
-                                 #val1 " " #op " " #val2))      \
+  if (std::string* _result = cef::logging::Check##name##Impl( \
+          (val1), (val2), #val1 " " #op " " #val2))           \
  cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()

 // Build the error message string.  This is separate from the "Impl"
@@ -374,20 +371,25 @@ std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
 #if !defined(COMPILER_MSVC)
 // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
 // in logging.cc.
-extern template std::string* MakeCheckOpString<int, int>(
-    const int&, const int&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned long, unsigned long>(
-    const unsigned long&, const unsigned long&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned long, unsigned int>(
-    const unsigned long&, const unsigned int&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned int, unsigned long>(
-    const unsigned int&, const unsigned long&, const char* names);
-extern template
-std::string* MakeCheckOpString<std::string, std::string>(
-    const std::string&, const std::string&, const char* name);
+extern template std::string* MakeCheckOpString<int, int>(const int&,
+                                                         const int&,
+                                                         const char* names);
+extern template std::string* MakeCheckOpString<unsigned long, unsigned long>(
+    const unsigned long&,
+    const unsigned long&,
+    const char* names);
+extern template std::string* MakeCheckOpString<unsigned long, unsigned int>(
+    const unsigned long&,
+    const unsigned int&,
+    const char* names);
+extern template std::string* MakeCheckOpString<unsigned int, unsigned long>(
+    const unsigned int&,
+    const unsigned long&,
+    const char* names);
+extern template std::string* MakeCheckOpString<std::string, std::string>(
+    const std::string&,
+    const std::string&,
+    const char* name);
 #endif

 // Helper functions for CHECK_OP macro.
@@ -398,12 +400,16 @@ std::string* MakeCheckOpString<std::string, std::string>(
  template <class t1, class t2>                                              \
  inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
                                        const char* names) {                 \
-    if (v1 op v2) return NULL; \
-    else return MakeCheckOpString(v1, v2, names); \
+    if (v1 op v2)                                                            \
+      return NULL;                                                           \
+    else                                                                     \
+      return MakeCheckOpString(v1, v2, names);                               \
  }                                                                          \
  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
-    if (v1 op v2) return NULL; \
-    else return MakeCheckOpString(v1, v2, names); \
+    if (v1 op v2)                                                            \
+      return NULL;                                                           \
+    else                                                                     \
+      return MakeCheckOpString(v1, v2, names);                               \
  }
 DEFINE_CHECK_OP_IMPL(EQ, ==)
 DEFINE_CHECK_OP_IMPL(NE, !=)
@@ -471,11 +477,9 @@ enum { DEBUG_MODE = ENABLE_DLOG };

 #undef ENABLE_DLOG

-#define DLOG(severity)                                          \
-  LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
+#define DLOG(severity) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))

-#define DPLOG(severity)                                         \
-  LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
+#define DPLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))

 #define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))

@@ -519,8 +523,9 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
  if (DCHECK_IS_ON())                                                      \
    if (std::string* _result = cef::logging::Check##name##Impl(            \
            (val1), (val2), #val1 " " #op " " #val2))                      \
-  cef::logging::LogMessage(__FILE__, __LINE__,                            \
-      ::cef::logging::LOG_DCHECK, _result).stream()
+  cef::logging::LogMessage(__FILE__, __LINE__, ::cef::logging::LOG_DCHECK, \
+                           _result)                                        \
+      .stream()

 // Equality/Inequality checks - compare two values, and log a
 // LOG_DCHECK message including the two values when the result is not
@@ -549,8 +554,8 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
 #define DCHECK_GT(val1, val2) DCHECK_OP(GT, >, val1, val2)

 #if defined(NDEBUG) && defined(OS_CHROMEOS)
-#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \
-    __FUNCTION__ << ". "
+#define NOTREACHED() \
+  LOG(ERROR) << "NOTREACHED() hit in " << __FUNCTION__ << ". "
 #else
 #define NOTREACHED() DCHECK(false)
 #endif
@@ -577,7 +582,9 @@ class LogMessage {
  LogMessage(const char* file, int line, std::string* result);

  // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
-  LogMessage(const char* file, int line, LogSeverity severity,
+  LogMessage(const char* file,
+             int line,
+             LogSeverity severity,
             std::string* result);

  ~LogMessage();
@@ -739,7 +746,8 @@ inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
 #elif NOTIMPLEMENTED_POLICY == 4
 #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
 #elif NOTIMPLEMENTED_POLICY == 5
-#define NOTIMPLEMENTED() do {\
+#define NOTIMPLEMENTED()                               \
+  do {                                                 \
    static bool logged_once = false;                   \
    LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
    logged_once = true;                                \
--- a/include/base/cef_macros.h
+++ b/include/base/cef_macros.h
@@ -126,14 +126,13 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
 namespace cef {

 template <bool>
-struct CompileAssert {
-};
+struct CompileAssert {};

 }  // namespace cef

 #define COMPILE_ASSERT(expr, msg)          \
-  typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \
-      ALLOW_UNUSED_TYPE
+  typedef cef::CompileAssert<(bool(expr))> \
+      msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE

 // Implementation details of COMPILE_ASSERT:
 //
@@ -182,13 +181,12 @@ struct CompileAssert {

 #endif  // !USING_CHROMIUM_INCLUDES

-#if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
-#if defined(COMPILER_MSVC)
+#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))
+#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
@@ -198,6 +196,10 @@ struct CompileAssert {
 // 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|.
@@ -207,13 +209,11 @@ struct CompileAssert {
 //
 // 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()
+#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

--- a/include/base/cef_move.h
+++ b/include/base/cef_move.h
@@ -248,10 +248,12 @@
  };                                                       \
  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
--- a/include/base/cef_platform_thread.h
+++ b/include/base/cef_platform_thread.h
@@ -69,21 +69,14 @@ class PlatformThreadRef {
 public:
  typedef cef_platform_thread_handle_t RefType;

-  PlatformThreadRef()
-      : id_(0) {
-  }
+  PlatformThreadRef() : id_(0) {}

-  explicit PlatformThreadRef(RefType id)
-      : id_(id) {
-  }
+  explicit PlatformThreadRef(RefType id) : id_(id) {}

-  bool operator==(PlatformThreadRef other) const {
-    return id_ == other.id_;
-  }
+  bool operator==(PlatformThreadRef other) const { return id_ == other.id_; }
+
+  bool is_null() const { return id_ == 0; }

-  bool is_null() const {
-    return id_ == 0;
-  }
 private:
  RefType id_;
 };
--- a/include/base/cef_ref_counted.h
+++ b/include/base/cef_ref_counted.h
@@ -65,7 +65,8 @@ class RefCountedBase {
  RefCountedBase()
      : ref_count_(0)
 #if DCHECK_IS_ON()
-      , in_dtor_(false)
+        ,
+        in_dtor_(false)
 #endif
  {
  }
@@ -76,7 +77,6 @@ class RefCountedBase {
 #endif
  }

-
  void AddRef() const {
 // TODO(maruel): Add back once it doesn't assert 500 times/sec.
 // Current thread books the critical section "AddRelease"
@@ -160,9 +160,7 @@ class RefCounted : public cef_subtle::RefCountedBase {
 public:
  RefCounted() {}

-  void AddRef() const {
-    cef_subtle::RefCountedBase::AddRef();
-  }
+  void AddRef() const { cef_subtle::RefCountedBase::AddRef(); }

  void Release() const {
    if (cef_subtle::RefCountedBase::Release()) {
@@ -178,7 +176,8 @@ class RefCounted : public cef_subtle::RefCountedBase {
 };

 // Forward declaration.
-template <class T, typename Traits> class RefCountedThreadSafe;
+template <class T, typename Traits>
+class RefCountedThreadSafe;

 // Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
 // count reaches 0.  Overload to delete it on a different thread etc.
@@ -188,8 +187,8 @@ struct DefaultRefCountedThreadSafeTraits {
    // Delete through RefCountedThreadSafe to make child classes only need to be
    // friend with RefCountedThreadSafe instead of this struct, which is an
    // implementation detail.
-    RefCountedThreadSafe<T,
-                         DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
+    RefCountedThreadSafe<T, DefaultRefCountedThreadSafeTraits>::DeleteInternal(
+        x);
  }
 };

@@ -210,9 +209,7 @@ class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
 public:
  RefCountedThreadSafe() {}

-  void AddRef() const {
-    cef_subtle::RefCountedThreadSafeBase::AddRef();
-  }
+  void AddRef() const { cef_subtle::RefCountedThreadSafeBase::AddRef(); }

  void Release() const {
    if (cef_subtle::RefCountedThreadSafeBase::Release()) {
@@ -303,8 +300,7 @@ class scoped_refptr {
 public:
  typedef T element_type;

-  scoped_refptr() : ptr_(NULL) {
-  }
+  scoped_refptr() : ptr_(NULL) {}

  scoped_refptr(T* p) : ptr_(p) {
    if (ptr_)
@@ -364,9 +360,7 @@ class scoped_refptr {
    *pp = p;
  }

-  void swap(scoped_refptr<T>& r) {
-    swap(&r.ptr_);
-  }
+  void swap(scoped_refptr<T>& r) { swap(&r.ptr_); }

 protected:
  T* ptr_;
--- a/include/base/cef_scoped_ptr.h
+++ b/include/base/cef_scoped_ptr.h
@@ -154,7 +154,8 @@ class RefCountedThreadSafeBase;
 template <class T>
 struct DefaultDeleter {
  DefaultDeleter() {}
-  template <typename U> DefaultDeleter(const DefaultDeleter<U>& other) {
+  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.
    //
@@ -194,7 +195,8 @@ struct DefaultDeleter<T[]> {
  // References:
  //   C++98 [expr.delete]p3
  //   http://cplusplus.github.com/LWG/lwg-defects.html#938
-  template <typename U> void operator()(U* array) const;
+  template <typename U>
+  void operator()(U* array) const;
 };

 template <class T, int n>
@@ -209,18 +211,18 @@ struct DefaultDeleter<T[n]> {
 // scoped_ptr<int, base::FreeDeleter> foo_ptr(
 //     static_cast<int*>(malloc(sizeof(int))));
 struct FreeDeleter {
-  inline void operator()(void* ptr) const {
-    free(ptr);
-  }
+  inline void operator()(void* ptr) const { free(ptr); }
 };

 namespace cef_internal {

-template <typename T> struct IsNotRefCounted {
+template <typename T>
+struct IsNotRefCounted {
  enum {
-    value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
-        !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
-            value
+    value =
+        !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
+        !base::is_convertible<T*,
+                              base::subtle::RefCountedThreadSafeBase*>::value
  };
 };

@@ -309,7 +311,8 @@ class scoped_ptr_impl {

 private:
  // Needed to allow type-converting constructor.
-  template <typename U, typename V> friend class scoped_ptr_impl;
+  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
@@ -443,18 +446,14 @@ class scoped_ptr {
  bool operator!=(const element_type* p) const { return impl_.get() != p; }

  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) {
-    impl_.swap(p2.impl_);
-  }
+  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();
-  }
+  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
@@ -469,7 +468,8 @@ class scoped_ptr {

 private:
  // Needed to reach into |impl_| in the constructor.
-  template <typename U, typename V> friend class scoped_ptr;
+  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.
@@ -479,8 +479,10 @@ class scoped_ptr {
  // 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 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>
@@ -553,18 +555,14 @@ class scoped_ptr<T[], D> {
  bool operator!=(element_type* array) const { return impl_.get() != array; }

  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) {
-    impl_.swap(p2.impl_);
-  }
+  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();
-  }
+  element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }

 private:
  // Force element_type to be a complete type.
@@ -578,20 +576,24 @@ class scoped_ptr<T[], D> {
  // 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);
+  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);
+  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;
+  template <class U>
+  bool operator==(scoped_ptr<U> const& p2) const;
+  template <class U>
+  bool operator!=(scoped_ptr<U> const& p2) const;
 };

 // Free functions
--- a/include/base/cef_string16.h
+++ b/include/base/cef_string16.h
@@ -112,26 +112,19 @@ struct string16_char_traits {
  typedef mbstate_t state_type;
  typedef std::fpos<state_type> pos_type;

-  static void assign(char_type& c1, const char_type& c2) {
-    c1 = c2;
-  }
+  static void assign(char_type& c1, const char_type& c2) { c1 = c2; }

-  static bool eq(const char_type& c1, const char_type& c2) {
-    return c1 == c2;
-  }
-  static bool lt(const char_type& c1, const char_type& c2) {
-    return c1 < c2;
-  }
+  static bool eq(const char_type& c1, const char_type& c2) { return c1 == c2; }
+  static bool lt(const char_type& c1, const char_type& c2) { return c1 < c2; }

  static int compare(const char_type* s1, const char_type* s2, size_t n) {
    return c16memcmp(s1, s2, n);
  }

-  static size_t length(const char_type* s) {
-    return c16len(s);
-  }
+  static size_t length(const char_type* s) { return c16len(s); }

-  static const char_type* find(const char_type* s, size_t n,
+  static const char_type* find(const char_type* s,
+                               size_t n,
                               const char_type& a) {
    return c16memchr(s, a, n);
  }
@@ -152,21 +145,15 @@ struct string16_char_traits {
    return eq_int_type(c, eof()) ? 0 : c;
  }

-  static char_type to_char_type(const int_type& c) {
-    return char_type(c);
-  }
+  static char_type to_char_type(const int_type& c) { return char_type(c); }

-  static int_type to_int_type(const char_type& c) {
-    return int_type(c);
-  }
+  static int_type to_int_type(const char_type& c) { return int_type(c); }

  static bool eq_int_type(const int_type& c1, const int_type& c2) {
    return c1 == c2;
  }

-  static int_type eof() {
-    return static_cast<int_type>(EOF);
-  }
+  static int_type eof() { return static_cast<int_type>(EOF); }
 };

 typedef std::basic_string<char16, base::string16_char_traits> string16;
@@ -217,8 +204,8 @@ extern void PrintTo(const string16& str, std::ostream* out);
 //
 // TODO(mark): File this bug with Apple and update this note with a bug number.

-extern template
-class std::basic_string<base::char16, base::string16_char_traits>;
+extern template class std::basic_string<base::char16,
+                                        base::string16_char_traits>;

 #endif  // WCHAR_T_IS_UTF32

--- a/include/base/cef_template_util.h
+++ b/include/base/cef_template_util.h
@@ -60,13 +60,16 @@ struct integral_constant {
  typedef integral_constant<T, v> type;
 };

-template <class T, T v> const T integral_constant<T, v>::value;
+template <class T, T v>
+const T integral_constant<T, v>::value;

 typedef integral_constant<bool, true> true_type;
 typedef integral_constant<bool, false> false_type;

-template <class T> struct is_pointer : false_type {};
-template <class T> struct is_pointer<T*> : true_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.
@@ -93,30 +96,49 @@ 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,
+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,
+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 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> 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_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_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 {};
+template <class T>
+struct is_void : false_type {};
+template <>
+struct is_void<void> : true_type {};

 namespace cef_internal {

@@ -169,21 +191,21 @@ struct is_convertible
    : integral_constant<bool,
                        sizeof(cef_internal::ConvertHelper::Test<To>(
                            cef_internal::ConvertHelper::Create<From>())) ==
-                        sizeof(cef_internal::YesType)> {
-};
+                            sizeof(cef_internal::YesType)> {};

 template <typename T>
 struct is_class
    : integral_constant<bool,
                        sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
-                            sizeof(cef_internal::YesType)> {
-};
+                            sizeof(cef_internal::YesType)> {};

 template <bool B, class T = void>
 struct enable_if {};

 template <class T>
-struct enable_if<true, T> { typedef T type; };
+struct enable_if<true, T> {
+  typedef T type;
+};

 }  // namespace base

--- a/include/base/cef_thread_checker.h
+++ b/include/base/cef_thread_checker.h
@@ -58,7 +58,6 @@
 #define ENABLE_THREAD_CHECKER 0
 #endif

-
 namespace base {

 namespace cef_internal {
@@ -69,9 +68,7 @@ namespace cef_internal {
 // right version for your build configuration.
 class ThreadCheckerDoNothing {
 public:
-  bool CalledOnValidThread() const {
-    return true;
-  }
+  bool CalledOnValidThread() const { return true; }

  void DetachFromThread() {}
 };
@@ -110,11 +107,9 @@ class ThreadCheckerDoNothing {
 //
 // In Release mode, CalledOnValidThread will always return true.
 #if ENABLE_THREAD_CHECKER
-class ThreadChecker : public cef_internal::ThreadCheckerImpl {
-};
+class ThreadChecker : public cef_internal::ThreadCheckerImpl {};
 #else
-class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {
-};
+class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {};
 #endif  // ENABLE_THREAD_CHECKER

 #undef ENABLE_THREAD_CHECKER
--- a/include/base/cef_thread_collision_warner.h
+++ b/include/base/cef_thread_collision_warner.h
@@ -139,13 +139,11 @@
 //   DFAKE_MUTEX(shareable_section_);
 // };

-
 #if DCHECK_IS_ON()

 // Defines a class member that acts like a mutex. It is used only as a
 // verification tool.
-#define DFAKE_MUTEX(obj) \
-     mutable base::ThreadCollisionWarner obj
+#define DFAKE_MUTEX(obj) mutable base::ThreadCollisionWarner obj
 // Asserts the call is never called simultaneously in two threads. Used at
 // member function scope.
 #define DFAKE_SCOPED_LOCK(obj) \
@@ -187,13 +185,9 @@ class ThreadCollisionWarner {
 public:
  // The parameter asserter is there only for test purpose
  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
-      : valid_thread_id_(0),
-        counter_(0),
-        asserter_(asserter) {}
+      : valid_thread_id_(0), counter_(0), asserter_(asserter) {}

-  ~ThreadCollisionWarner() {
-    delete asserter_;
-  }
+  ~ThreadCollisionWarner() { delete asserter_; }

  // This class is meant to be used through the macro
  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
@@ -202,8 +196,7 @@ class ThreadCollisionWarner {
  // from one thread
  class Check {
   public:
-    explicit Check(ThreadCollisionWarner* warner)
-        : warner_(warner) {
+    explicit Check(ThreadCollisionWarner* warner) : warner_(warner) {
      warner_->EnterSelf();
    }

@@ -219,14 +212,11 @@ class ThreadCollisionWarner {
  // DFAKE_SCOPED_LOCK
  class ScopedCheck {
   public:
-    explicit ScopedCheck(ThreadCollisionWarner* warner)
-        : warner_(warner) {
+    explicit ScopedCheck(ThreadCollisionWarner* warner) : warner_(warner) {
      warner_->Enter();
    }

-    ~ScopedCheck() {
-      warner_->Leave();
-    }
+    ~ScopedCheck() { warner_->Leave(); }

   private:
    ThreadCollisionWarner* warner_;
@@ -243,9 +233,7 @@ class ThreadCollisionWarner {
      warner_->EnterSelf();
    }

-    ~ScopedRecursiveCheck() {
-      warner_->Leave();
-    }
+    ~ScopedRecursiveCheck() { warner_->Leave(); }

   private:
    ThreadCollisionWarner* warner_;
--- a/include/base/cef_trace_event.h
+++ b/include/base/cef_trace_event.h
@@ -166,26 +166,23 @@
 #define TRACE_EVENT1(category, name, arg1_name, arg1_val)                     \
  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
-#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, \
-      arg2_val) \
-  cef_trace_event_begin(category, name, arg1_name, arg1_val, \
-                                        arg2_name, arg2_val, false); \
+#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
+  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name,        \
+                        arg2_val, false);                                      \
  CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)

 // Implementation detail: trace event macros create temporary variable names.
 // These macros give each temporary variable a unique name based on the line
 // number to prevent name collisions.
-#define CEF_INTERNAL_TRACE_EVENT_UID3(a,b) \
-  cef_trace_event_unique_##a##b
-#define CEF_INTERNAL_TRACE_EVENT_UID2(a,b) \
-  CEF_INTERNAL_TRACE_EVENT_UID3(a,b)
+#define CEF_INTERNAL_TRACE_EVENT_UID3(a, b) cef_trace_event_unique_##a##b
+#define CEF_INTERNAL_TRACE_EVENT_UID2(a, b) CEF_INTERNAL_TRACE_EVENT_UID3(a, b)
 #define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \
  CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)

 // Implementation detail: internal macro to end end event when the scope ends.
 #define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)            \
-   cef_trace_event::CefTraceEndOnScopeClose \
-       CEF_INTERNAL_TRACE_EVENT_UID(profileScope)(category, name)
+  cef_trace_event::CefTraceEndOnScopeClose CEF_INTERNAL_TRACE_EVENT_UID( \
+      profileScope)(category, name)

 // Records a single event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
@@ -196,8 +193,8 @@
  cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
 #define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
  cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
-#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \
-      arg2_name, arg2_val) \
+#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
+                             arg2_val)                                       \
  cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name,    \
                          arg2_val, false)
 #define TRACE_EVENT_COPY_INSTANT0(category, name) \
@@ -218,8 +215,8 @@
  cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
 #define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
  cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
-#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \
-      arg2_name, arg2_val) \
+#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
+                           arg2_val)                                       \
  cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name,    \
                        arg2_val, false)
 #define TRACE_EVENT_COPY_BEGIN0(category, name) \
@@ -239,16 +236,16 @@
  cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
 #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
-#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
-      arg2_name, arg2_val) \
+#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                         arg2_val)                                       \
  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name,    \
                      arg2_val, false)
 #define TRACE_EVENT_COPY_END0(category, name) \
  cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
 #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
  cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
-#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
-      arg2_name, arg2_val) \
+#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                              arg2_val)                                       \
  cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name,         \
                      arg2_val, true)

@@ -266,8 +263,8 @@
 // values as a stacked-bar chart.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_COUNTER2(category, name, value1_name, value1_val, \
-      value2_name, value2_val) \
+#define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
+                       value2_val)                                           \
  cef_trace_counter(category, name, value1_name, value1_val, value2_name,    \
                    value2_val, false)
 #define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val,      \
@@ -301,12 +298,11 @@
                          value2_name, value2_val)                     \
  cef_trace_counter_id(category, name, id, value1_name, value1_val,    \
                       value2_name, value2_val, false)
-#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, \
-      value1_val, value2_name, value2_val) \
+#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
+                               value2_name, value2_val)                     \
  cef_trace_counter_id(category, name, id, value1_name, value1_val,         \
                       value2_name, value2_val, true)

-
 // Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
 // does nothing.
@@ -334,12 +330,11 @@
                              arg2_name, arg2_val, false)
 #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
  cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, \
-      arg1_val) \
+#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL,   \
                              0, true)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, \
-      arg1_val, arg2_name, arg2_val) \
+#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
+                                      arg2_name, arg2_val)                     \
  cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val,         \
                              arg2_name, arg2_val, true)

@@ -351,14 +346,14 @@
 // ASYNC_STEP_PAST events.
 #define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
-#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, \
-      arg1_name, arg1_val) \
+#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
+                                     arg1_val)                            \
  cef_trace_event_async_step_into(category, name, id, step, arg1_name,    \
                                  arg1_val, false)
 #define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
  cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, \
-      arg1_name, arg1_val) \
+#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
+                                          arg1_val)                            \
  cef_trace_event_async_step_into(category, name, id, step, arg1_name,         \
                                  arg1_val, true)

@@ -370,14 +365,14 @@
 // ASYNC_STEP_INTO events.
 #define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
-#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, \
-      arg1_name, arg1_val) \
+#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
+                                     arg1_val)                            \
  cef_trace_event_async_step_past(category, name, id, step, arg1_name,    \
                                  arg1_val, false)
 #define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
  cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, \
-      arg1_name, arg1_val) \
+#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
+                                          arg1_val)                            \
  cef_trace_event_async_step_past(category, name, id, step, arg1_name,         \
                                  arg1_val, true)

@@ -394,12 +389,11 @@
                            arg2_name, arg2_val, false)
 #define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
  cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
-#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, \
-      arg1_val) \
+#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val)  \
  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
                            true)
-#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, \
-      arg1_val, arg2_name, arg2_val) \
+#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
+                                    arg2_name, arg2_val)                     \
  cef_trace_event_async_end(category, name, id, arg1_name, arg1_val,         \
                            arg2_name, arg2_val, true)

@@ -409,8 +403,7 @@ namespace cef_trace_event {
 class CefTraceEndOnScopeClose {
 public:
  CefTraceEndOnScopeClose(const char* category, const char* name)
-      : category_(category), name_(name) {
-  }
+      : category_(category), name_(name) {}
  ~CefTraceEndOnScopeClose() {
    cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
  }
--- a/include/base/cef_tuple.h
+++ b/include/base/cef_tuple.h
--- a/include/base/cef_weak_ptr.h
+++ b/include/base/cef_weak_ptr.h
@@ -117,8 +117,10 @@

 namespace base {

-template <typename T> class SupportsWeakPtr;
-template <typename T> class WeakPtr;
+template <typename T>
+class SupportsWeakPtr;
+template <typename T>
+class WeakPtr;

 namespace cef_internal {
 // These classes are part of the WeakPtr implementation.
@@ -164,9 +166,7 @@ class WeakReferenceOwner {

  WeakReference GetRef() const;

-  bool HasRefs() const {
-    return flag_.get() && !flag_->HasOneRef();
-  }
+  bool HasRefs() const { return flag_.get() && !flag_->HasOneRef(); }

  void Invalidate();

@@ -200,8 +200,8 @@ class SupportsWeakPtrBase {
  // function that makes calling this easier.
  template <typename Derived>
  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
-    typedef
-        is_convertible<Derived, cef_internal::SupportsWeakPtrBase&> convertible;
+    typedef is_convertible<Derived, cef_internal::SupportsWeakPtrBase&>
+        convertible;
    COMPILE_ASSERT(convertible::value,
                   AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
    return AsWeakPtrImpl<Derived>(t, *t);
@@ -212,8 +212,8 @@ 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, const SupportsWeakPtr<Base>&) {
+  static WeakPtr<Derived> AsWeakPtrImpl(Derived* t,
+                                        const SupportsWeakPtr<Base>&) {
    WeakPtr<Base> ptr = t->Base::AsWeakPtr();
    return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
  }
@@ -221,7 +221,8 @@ class SupportsWeakPtrBase {

 }  // namespace cef_internal

-template <typename T> class WeakPtrFactory;
+template <typename T>
+class WeakPtrFactory;

 // The WeakPtr class holds a weak reference to |T*|.
 //
@@ -239,14 +240,12 @@ template <typename T> class WeakPtrFactory;
 template <typename T>
 class WeakPtr : public cef_internal::WeakPtrBase {
 public:
-  WeakPtr() : ptr_(NULL) {
-  }
+  WeakPtr() : ptr_(NULL) {}

  // Allow conversion from U to T provided U "is a" T. Note that this
  // is separate from the (implicit) copy constructor.
  template <typename U>
-  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {
-  }
+  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {}

  T* get() const { return ref_.is_valid() ? ptr_ : NULL; }

@@ -280,18 +279,19 @@ class WeakPtr : public cef_internal::WeakPtrBase {
 private:
  // Explicitly declare comparison operators as required by the bool
  // trick, but keep them private.
-  template <class U> bool operator==(WeakPtr<U> const&) const;
-  template <class U> bool operator!=(WeakPtr<U> const&) const;
+  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;
+  template <typename U>
+  friend class WeakPtr;
  friend class SupportsWeakPtr<T>;
  friend class WeakPtrFactory<T>;

  WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
-      : WeakPtrBase(ref),
-        ptr_(ptr) {
-  }
+      : WeakPtrBase(ref), ptr_(ptr) {}

  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
  // value is undefined (as opposed to NULL).
@@ -306,12 +306,9 @@ class WeakPtr : public cef_internal::WeakPtrBase {
 template <class T>
 class WeakPtrFactory {
 public:
-  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {
-  }
+  explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {}

-  ~WeakPtrFactory() {
-    ptr_ = NULL;
-  }
+  ~WeakPtrFactory() { ptr_ = NULL; }

  WeakPtr<T> GetWeakPtr() {
    DCHECK(ptr_);
--- a/include/base/internal/cef_atomicops_arm_gcc.h
+++ b/include/base/internal/cef_atomicops_arm_gcc.h
@@ -103,7 +103,8 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
    //   reloop = 0
    //   if (prev_value != old_value)
    //      reloop = STREX(ptr, new_value)
-    __asm__ __volatile__("    ldrex %0, [%3]\n"
+    __asm__ __volatile__(
+        "    ldrex %0, [%3]\n"
        "    mov %1, #0\n"
        "    cmp %0, %4\n"
 #ifdef __thumb2__
@@ -143,7 +144,8 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
    //  value += increment
    //  reloop = STREX(ptr, value)
    //
-    __asm__ __volatile__("    ldrex %0, [%3]\n"
+    __asm__ __volatile__(
+        "    ldrex %0, [%3]\n"
        "    add %0, %0, %4\n"
        "    strex %1, %0, [%3]\n"
        : "=&r"(value), "=&r"(reloop), "+m"(*ptr)
@@ -171,7 +173,8 @@ inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
  do {
    // old_value = LDREX(ptr)
    // reloop = STREX(ptr, new_value)
-    __asm__ __volatile__("   ldrex %0, [%3]\n"
+    __asm__ __volatile__(
+        "   ldrex %0, [%3]\n"
        "   strex %1, %4, [%3]\n"
        : "=&r"(old_value), "=&r"(reloop), "+m"(*ptr)
        : "r"(ptr), "r"(new_value)
@@ -301,7 +304,9 @@ inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
  *ptr = value;
 }

-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { return *ptr; }
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}

 inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
  Atomic32 value = *ptr;
--- a/include/base/internal/cef_atomicops_atomicword_compat.h
+++ b/include/base/internal/cef_atomicops_atomicword_compat.h
@@ -52,26 +52,26 @@ 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);
+  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);
+  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);
+  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);
+  return Barrier_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
+                                 increment);
 }

 inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
@@ -89,23 +89,21 @@ inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
 }

 inline void NoBarrier_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  NoBarrier_Store(
-      reinterpret_cast<volatile Atomic32*>(ptr), 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);
+  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);
+  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));
+  return NoBarrier_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
 }

 inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
--- a/include/base/internal/cef_atomicops_x86_gcc.h
+++ b/include/base/internal/cef_atomicops_x86_gcc.h
@@ -41,8 +41,7 @@ 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;
+extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures;

 #define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")

@@ -76,7 +75,8 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
  Atomic32 temp = increment;
  __asm__ __volatile__("lock; xaddl %0,%1"
                       : "+r"(temp), "+m"(*ptr)
-                       : : "memory");
+                       :
+                       : "memory");
  // temp now holds the old value of *ptr
  return temp + increment;
 }
@@ -86,7 +86,8 @@ inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
  Atomic32 temp = increment;
  __asm__ __volatile__("lock; xaddl %0,%1"
                       : "+r"(temp), "+m"(*ptr)
-                       : : "memory");
+                       :
+                       : "memory");
  // temp now holds the old value of *ptr
  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
    __asm__ __volatile__("lfence" : : : "memory");
@@ -174,7 +175,8 @@ inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
  Atomic64 temp = increment;
  __asm__ __volatile__("lock; xaddq %0,%1"
                       : "+r"(temp), "+m"(*ptr)
-                       : : "memory");
+                       :
+                       : "memory");
  // temp now contains the previous value of *ptr
  return temp + increment;
 }
@@ -184,7 +186,8 @@ inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
  Atomic64 temp = increment;
  __asm__ __volatile__("lock; xaddq %0,%1"
                       : "+r"(temp), "+m"(*ptr)
-                       : : "memory");
+                       :
+                       : "memory");
  // temp now contains the previous value of *ptr
  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
    __asm__ __volatile__("lfence" : : : "memory");
--- a/include/base/internal/cef_atomicops_x86_msvc.h
+++ b/include/base/internal/cef_atomicops_x86_msvc.h
@@ -55,25 +55,23 @@ 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),
+      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),
+  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;
+  return _InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+                                 static_cast<LONG>(increment)) +
+         increment;
 }

 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
@@ -151,17 +149,17 @@ inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,

 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
                                         Atomic64 new_value) {
-  PVOID result = InterlockedExchangePointer(
-    reinterpret_cast<volatile PVOID*>(ptr),
+  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;
+  return InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr),
+                                  static_cast<LONGLONG>(increment)) +
+         increment;
 }

 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
@@ -215,7 +213,6 @@ inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 }

-
 #endif  // defined(_WIN64)

 }  // namespace base::subtle
--- a/include/base/internal/cef_bind_internal.h
+++ b/include/base/internal/cef_bind_internal.h
--- a/include/base/internal/cef_bind_internal_win.h
+++ b/include/base/internal/cef_bind_internal_win.h
@@ -52,13 +52,9 @@ class RunnableAdapter<R(__stdcall *)()> {
 public:
  typedef R(RunType)();

-  explicit RunnableAdapter(R(__stdcall *function)())
-      : function_(function) {
-  }
+  explicit RunnableAdapter(R(__stdcall* function)()) : function_(function) {}

-  R Run() {
-    return function_();
-  }
+  R Run() { return function_(); }

 private:
  R(__stdcall* function_)();
@@ -70,13 +66,9 @@ class RunnableAdapter<R(__fastcall *)()> {
 public:
  typedef R(RunType)();

-  explicit RunnableAdapter(R(__fastcall *function)())
-      : function_(function) {
-  }
+  explicit RunnableAdapter(R(__fastcall* function)()) : function_(function) {}

-  R Run() {
-    return function_();
-  }
+  R Run() { return function_(); }

 private:
  R(__fastcall* function_)();
@@ -88,9 +80,7 @@ class RunnableAdapter<R(__stdcall *)(A1)> {
 public:
  typedef R(RunType)(A1);

-  explicit RunnableAdapter(R(__stdcall *function)(A1))
-      : function_(function) {
-  }
+  explicit RunnableAdapter(R(__stdcall* function)(A1)) : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
    return function_(a1);
@@ -106,9 +96,7 @@ class RunnableAdapter<R(__fastcall *)(A1)> {
 public:
  typedef R(RunType)(A1);

-  explicit RunnableAdapter(R(__fastcall *function)(A1))
-      : function_(function) {
-  }
+  explicit RunnableAdapter(R(__fastcall* function)(A1)) : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
    return function_(a1);
@@ -125,8 +113,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2)> {
  typedef R(RunType)(A1, A2);

  explicit RunnableAdapter(R(__stdcall* function)(A1, A2))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2) {
@@ -144,8 +131,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2)> {
  typedef R(RunType)(A1, A2);

  explicit RunnableAdapter(R(__fastcall* function)(A1, A2))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2) {
@@ -163,8 +149,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
  typedef R(RunType)(A1, A2, A3);

  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -183,8 +168,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
  typedef R(RunType)(A1, A2, A3);

  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -203,8 +187,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
  typedef R(RunType)(A1, A2, A3, A4);

  explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -224,8 +207,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
  typedef R(RunType)(A1, A2, A3, A4);

  explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4))
-      : function_(function) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -239,15 +221,18 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
 };

 // __stdcall Function: Arity 5.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -262,15 +247,18 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
 };

 // __fastcall Function: Arity 5.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -285,15 +273,19 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
 };

 // __stdcall Function: Arity 6.
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -309,15 +301,19 @@ class RunnableAdapter<R(__stdcall *)(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>
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -333,15 +329,20 @@ class RunnableAdapter<R(__fastcall *)(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>
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
@@ -358,15 +359,20 @@ class RunnableAdapter<R(__stdcall *)(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>
+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) {
-  }
+      : function_(function) {}

  R Run(typename CallbackParamTraits<A1>::ForwardType a1,
        typename CallbackParamTraits<A2>::ForwardType a2,
--- a/include/base/internal/cef_callback_internal.h
+++ b/include/base/internal/cef_callback_internal.h
@@ -115,15 +115,16 @@ class CallbackBase {
 // A helper template to determine if given type is non-const move-only-type,
 // i.e. if a value of the given type should be passed via .Pass() in a
 // destructive way.
-template <typename T> struct IsMoveOnlyType {
+template <typename T>
+struct IsMoveOnlyType {
  template <typename U>
  static YesType Test(const typename U::MoveOnlyTypeForCPP03*);

  template <typename U>
  static NoType Test(...);

-  static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
-                            !is_const<T>::value;
+  static const bool value =
+      sizeof(Test<T>(0)) == sizeof(YesType) && !is_const<T>::value;
 };

 // This is a typetraits object that's used to take an argument type, and
--- a/include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
+++ b/include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
@@ -51,9 +51,7 @@ namespace cef_internal {
 template <typename T>
 struct NeedsScopedRefptrButGetsRawPtr {
 #if defined(OS_WIN)
-  enum {
-    value = base::false_type::value
-  };
+  enum { value = base::false_type::value };
 #else
  enum {
    // Human readable translation: you needed to be a scoped_refptr if you are a
@@ -83,68 +81,97 @@ struct ParamsUseScopedRefptrCorrectly<Tuple1<A> > {

 template <typename A, typename B>
 struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B>> {
-  enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<B>::value) };
+  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 ||
+  enum {
+    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
              NeedsScopedRefptrButGetsRawPtr<B>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<C>::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 ||
+  enum {
+    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
              NeedsScopedRefptrButGetsRawPtr<B>::value ||
              NeedsScopedRefptrButGetsRawPtr<C>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<D>::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 ||
+  enum {
+    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
              NeedsScopedRefptrButGetsRawPtr<B>::value ||
              NeedsScopedRefptrButGetsRawPtr<C>::value ||
              NeedsScopedRefptrButGetsRawPtr<D>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<E>::value) };
+              NeedsScopedRefptrButGetsRawPtr<E>::value)
+  };
 };

-template <typename A, typename B, typename C, typename D, typename E,
+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 ||
+  enum {
+    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
              NeedsScopedRefptrButGetsRawPtr<B>::value ||
              NeedsScopedRefptrButGetsRawPtr<C>::value ||
              NeedsScopedRefptrButGetsRawPtr<D>::value ||
              NeedsScopedRefptrButGetsRawPtr<E>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<F>::value) };
+              NeedsScopedRefptrButGetsRawPtr<F>::value)
+  };
 };

-template <typename A, typename B, typename C, typename D, typename E,
-          typename F, typename G>
+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 ||
+  enum {
+    value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
              NeedsScopedRefptrButGetsRawPtr<B>::value ||
              NeedsScopedRefptrButGetsRawPtr<C>::value ||
              NeedsScopedRefptrButGetsRawPtr<D>::value ||
              NeedsScopedRefptrButGetsRawPtr<E>::value ||
              NeedsScopedRefptrButGetsRawPtr<F>::value ||
-                   NeedsScopedRefptrButGetsRawPtr<G>::value) };
+              NeedsScopedRefptrButGetsRawPtr<G>::value)
+  };
 };

-template <typename A, typename B, typename C, typename D, typename E,
-          typename F, typename G, typename H>
+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 ||
+  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) };
+              NeedsScopedRefptrButGetsRawPtr<H>::value)
+  };
 };

 }  // namespace cef_internal
--- a/include/capi/cef_accessibility_handler_capi.h
+++ b/include/capi/cef_accessibility_handler_capi.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2017 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=ade29136d75b33f63cf65db4b91de9cd66114562$
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
+#pragma once
+
+#include "include/capi/cef_values_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+// Implement this structure to receive accessibility notification when
+// accessibility events have been registered. The functions of this structure
+// will be called on the UI thread.
+///
+typedef struct _cef_accessibility_handler_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_ref_counted_t base;
+
+  ///
+  // Called after renderer process sends accessibility tree changes to the
+  // browser process.
+  ///
+  void(CEF_CALLBACK* on_accessibility_tree_change)(
+      struct _cef_accessibility_handler_t* self,
+      struct _cef_value_t* value);
+
+  ///
+  // Called after renderer process sends accessibility location changes to the
+  // browser process.
+  ///
+  void(CEF_CALLBACK* on_accessibility_location_change)(
+      struct _cef_accessibility_handler_t* self,
+      struct _cef_value_t* value);
+} cef_accessibility_handler_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
--- a/include/capi/cef_app_capi.h
+++ b/include/capi/cef_app_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=52ce63b881a6e3d2d13a39b81ad2626f366fc130$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@@ -59,7 +61,7 @@ typedef struct _cef_app_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Provides an opportunity to view and/or modify command-line arguments before
@@ -73,7 +75,8 @@ typedef struct _cef_app_t {
  // in undefined behavior including crashes.
  ///
  void(CEF_CALLBACK* on_before_command_line_processing)(
-      struct _cef_app_t* self, const cef_string_t* process_type,
+      struct _cef_app_t* self,
+      const cef_string_t* process_type,
      struct _cef_command_line_t* command_line);

  ///
@@ -82,7 +85,8 @@ typedef struct _cef_app_t {
  // each process and the registered schemes should be the same across all
  // processes.
  ///
-  void (CEF_CALLBACK *on_register_custom_schemes)(struct _cef_app_t* self,
+  void(CEF_CALLBACK* on_register_custom_schemes)(
+      struct _cef_app_t* self,
      struct _cef_scheme_registrar_t* registrar);

  ///
@@ -109,7 +113,6 @@ typedef struct _cef_app_t {
      CEF_CALLBACK* get_render_process_handler)(struct _cef_app_t* self);
 } cef_app_t;

-
 ///
 // This function should be called from the application entry point function to
 // execute a secondary process. It can be used to run secondary processes from
@@ -123,7 +126,8 @@ typedef struct _cef_app_t {
 // cef_sandbox_win.h for details).
 ///
 CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
-    cef_app_t* application, void* windows_sandbox_info);
+                                   cef_app_t* application,
+                                   void* windows_sandbox_info);

 ///
 // This function should be called on the main application thread to initialize
@@ -133,7 +137,8 @@ CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
 // be NULL (see cef_sandbox_win.h for details).
 ///
 CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
-    const struct _cef_settings_t* settings, cef_app_t* application,
+                              const struct _cef_settings_t* settings,
+                              cef_app_t* application,
                              void* windows_sandbox_info);

 ///
--- a/include/capi/cef_auth_callback_capi.h
+++ b/include/capi/cef_auth_callback_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=639d58245ecd39624d39ee8b49e0e4e056d1c4ed$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure used for asynchronous continuation of authentication
 // requests.
@@ -53,13 +54,14 @@ typedef struct _cef_auth_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue the authentication request.
  ///
  void(CEF_CALLBACK* cont)(struct _cef_auth_callback_t* self,
-      const cef_string_t* username, const cef_string_t* password);
+                           const cef_string_t* username,
+                           const cef_string_t* password);

  ///
  // Cancel the authentication request.
@@ -67,7 +69,6 @@ typedef struct _cef_auth_callback_t {
  void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self);
 } cef_auth_callback_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_base_capi.h
+++ b/include/capi/cef_base_capi.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-
 #ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_

@@ -45,10 +44,9 @@ extern "C" {
 #endif

 ///
-// Structure defining the reference count implementation functions. All
-// framework structures must include the cef_base_t structure first.
+// All ref-counted framework structures must include this structure first.
 ///
-typedef struct _cef_base_t {
+typedef struct _cef_base_ref_counted_t {
  ///
  // Size of the data structure.
  ///
@@ -58,31 +56,45 @@ typedef struct _cef_base_t {
  // Called to increment the reference count for the object. Should be called
  // for every new copy of a pointer to a given object.
  ///
-  void (CEF_CALLBACK *add_ref)(struct _cef_base_t* self);
+  void(CEF_CALLBACK* add_ref)(struct _cef_base_ref_counted_t* self);

  ///
  // Called to decrement the reference count for the object. If the reference
  // count falls to 0 the object should self-delete. Returns true (1) if the
  // resulting reference count is 0.
  ///
-  int (CEF_CALLBACK *release)(struct _cef_base_t* self);
+  int(CEF_CALLBACK* release)(struct _cef_base_ref_counted_t* self);

  ///
  // Returns true (1) if the current reference count is 1.
  ///
-  int (CEF_CALLBACK *has_one_ref)(struct _cef_base_t* self);
-} cef_base_t;
+  int(CEF_CALLBACK* has_one_ref)(struct _cef_base_ref_counted_t* self);
+} cef_base_ref_counted_t;

+///
+// All scoped framework structures must include this structure first.
+///
+typedef struct _cef_base_scoped_t {
+  ///
+  // Size of the data structure.
+  ///
+  size_t size;

-// Check that the structure |s|, which is defined with a cef_base_t member named
-// |base|, is large enough to contain the specified member |f|.
+  ///
+  // Called to delete this object. May be NULL if the object is not owned.
+  ///
+  void(CEF_CALLBACK* del)(struct _cef_base_scoped_t* self);
+
+} cef_base_scoped_t;
+
+// Check that the structure |s|, which is defined with a size_t member at the
+// top, is large enough to contain the specified member |f|.
 #define CEF_MEMBER_EXISTS(s, f) \
-  ((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \
-  reinterpret_cast<cef_base_t*>(s)->size)
+  ((intptr_t) &                 \
+   ((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= *reinterpret_cast<size_t*>(s))

 #define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_browser_capi.h
+++ b/include/capi/cef_browser_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=b6308ab5e97eb9f7af95f1f4c371fd6e7edbf852$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@@ -63,7 +65,7 @@ typedef struct _cef_browser_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the browser host object. This function can only be called in the
@@ -150,7 +152,8 @@ typedef struct _cef_browser_t {
  // Returns the frame with the specified identifier, or NULL if not found.
  ///
  struct _cef_frame_t*(CEF_CALLBACK* get_frame_byident)(
-      struct _cef_browser_t* self, int64 identifier);
+      struct _cef_browser_t* self,
+      int64 identifier);

  ///
  // Returns the frame with the specified name, or NULL if not found.
@@ -167,7 +170,8 @@ typedef struct _cef_browser_t {
  // Returns the identifiers of all existing frames.
  ///
  void(CEF_CALLBACK* get_frame_identifiers)(struct _cef_browser_t* self,
-      size_t* identifiersCount, int64* identifiers);
+                                            size_t* identifiersCount,
+                                            int64* identifiers);

  ///
  // Returns the names of all existing frames.
@@ -179,12 +183,12 @@ typedef struct _cef_browser_t {
  // Send a message to the specified |target_process|. Returns true (1) if the
  // message was sent successfully.
  ///
-  int (CEF_CALLBACK *send_process_message)(struct _cef_browser_t* self,
+  int(CEF_CALLBACK* send_process_message)(
+      struct _cef_browser_t* self,
      cef_process_id_t target_process,
      struct _cef_process_message_t* message);
 } cef_browser_t;

-
 ///
 // Callback structure for cef_browser_host_t::RunFileDialog. The functions of
 // this structure will be called on the browser process UI thread.
@@ -193,7 +197,7 @@ typedef struct _cef_run_file_dialog_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called asynchronously after the file dialog is dismissed.
@@ -203,11 +207,11 @@ typedef struct _cef_run_file_dialog_callback_t {
  // 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,
+      struct _cef_run_file_dialog_callback_t* self,
+      int selected_accept_filter,
      cef_string_list_t file_paths);
 } cef_run_file_dialog_callback_t;

-
 ///
 // Callback structure for cef_browser_host_t::GetNavigationEntries. The
 // functions of this structure will be called on the browser process UI thread.
@@ -216,7 +220,7 @@ typedef struct _cef_navigation_entry_visitor_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be executed. Do not keep a reference to |entry| outside of
@@ -226,11 +230,12 @@ typedef struct _cef_navigation_entry_visitor_t {
  // the total number of entries.
  ///
  int(CEF_CALLBACK* visit)(struct _cef_navigation_entry_visitor_t* self,
-      struct _cef_navigation_entry_t* entry, int current, int index,
+                           struct _cef_navigation_entry_t* entry,
+                           int current,
+                           int index,
                           int total);
 } cef_navigation_entry_visitor_t;

-
 ///
 // Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
 // structure will be called on the browser process UI thread.
@@ -239,7 +244,7 @@ typedef struct _cef_pdf_print_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be executed when the PDF printing has completed. |path| is
@@ -247,11 +252,11 @@ typedef struct _cef_pdf_print_callback_t {
  // successfully or false (0) otherwise.
  ///
  void(CEF_CALLBACK* on_pdf_print_finished)(
-      struct _cef_pdf_print_callback_t* self, const cef_string_t* path,
+      struct _cef_pdf_print_callback_t* self,
+      const cef_string_t* path,
      int ok);
 } cef_pdf_print_callback_t;

-
 ///
 // Callback structure for cef_browser_host_t::DownloadImage. The functions of
 // this structure will be called on the browser process UI thread.
@@ -260,7 +265,7 @@ typedef struct _cef_download_image_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be executed when the image download has completed.
@@ -270,11 +275,11 @@ typedef struct _cef_download_image_callback_t {
  ///
  void(CEF_CALLBACK* on_download_image_finished)(
      struct _cef_download_image_callback_t* self,
-      const cef_string_t* image_url, int http_status_code,
+      const cef_string_t* image_url,
+      int http_status_code,
      struct _cef_image_t* image);
 } cef_download_image_callback_t;

-
 ///
 // Structure used to represent the browser process aspects of a browser window.
 // The functions of this structure can only be called in the browser process.
@@ -285,7 +290,7 @@ typedef struct _cef_browser_host_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the hosted browser object.
@@ -385,9 +390,12 @@ typedef struct _cef_browser_host_t {
  // dismissed or immediately if another dialog is already pending. The dialog
  // will be initiated asynchronously on the UI thread.
  ///
-  void (CEF_CALLBACK *run_file_dialog)(struct _cef_browser_host_t* self,
-      cef_file_dialog_mode_t mode, const cef_string_t* title,
-      const cef_string_t* default_file_path, cef_string_list_t accept_filters,
+  void(CEF_CALLBACK* run_file_dialog)(
+      struct _cef_browser_host_t* self,
+      cef_file_dialog_mode_t mode,
+      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);

@@ -409,9 +417,13 @@ typedef struct _cef_browser_host_t {
  // unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
  // the server even if it is present in the browser cache.
  ///
-  void (CEF_CALLBACK *download_image)(struct _cef_browser_host_t* self,
-      const cef_string_t* image_url, int is_favicon, uint32 max_image_size,
-      int bypass_cache, struct _cef_download_image_callback_t* callback);
+  void(CEF_CALLBACK* download_image)(
+      struct _cef_browser_host_t* self,
+      const cef_string_t* image_url,
+      int is_favicon,
+      uint32 max_image_size,
+      int bypass_cache,
+      struct _cef_download_image_callback_t* callback);

  ///
  // Print the current browser contents.
@@ -424,21 +436,28 @@ typedef struct _cef_browser_host_t {
  // |path| when done. For PDF printing to work on Linux you must implement the
  // cef_print_handler_t::GetPdfPaperSize function.
  ///
-  void (CEF_CALLBACK *print_to_pdf)(struct _cef_browser_host_t* self,
+  void(CEF_CALLBACK* print_to_pdf)(
+      struct _cef_browser_host_t* self,
      const cef_string_t* path,
      const struct _cef_pdf_print_settings_t* settings,
      struct _cef_pdf_print_callback_t* callback);

  ///
-  // Search for |searchText|. |identifier| can be used to have multiple searches
-  // running simultaniously. |forward| indicates whether to search forward or
-  // backward within the page. |matchCase| indicates whether the search should
-  // be case-sensitive. |findNext| indicates whether this is the first request
-  // or a follow-up. The cef_find_handler_t instance, if any, returned via
-  // cef_client_t::GetFindHandler will be called to report find results.
+  // Search for |searchText|. |identifier| must be a unique ID and these IDs
+  // must strictly increase so that newer requests always have greater IDs than
+  // older requests. If |identifier| is zero or less than the previous ID value
+  // then it will be automatically assigned a new valid ID. |forward| indicates
+  // whether to search forward or backward within the page. |matchCase|
+  // indicates whether the search should be case-sensitive. |findNext| indicates
+  // whether this is the first request or a follow-up. The cef_find_handler_t
+  // 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,
+  void(CEF_CALLBACK* find)(struct _cef_browser_host_t* self,
+                           int identifier,
+                           const cef_string_t* searchText,
+                           int forward,
+                           int matchCase,
                           int findNext);

  ///
@@ -456,7 +475,8 @@ typedef struct _cef_browser_host_t {
  // inspected. The |windowInfo| parameter will be ignored if this browser is
  // wrapped in a cef_browser_view_t.
  ///
-  void (CEF_CALLBACK *show_dev_tools)(struct _cef_browser_host_t* self,
+  void(CEF_CALLBACK* show_dev_tools)(
+      struct _cef_browser_host_t* self,
      const struct _cef_window_info_t* windowInfo,
      struct _cef_client_t* client,
      const struct _cef_browser_settings_t* settings,
@@ -479,14 +499,17 @@ typedef struct _cef_browser_host_t {
  // navigation entry will be sent, otherwise all navigation entries will be
  // sent.
  ///
-  void (CEF_CALLBACK *get_navigation_entries)(struct _cef_browser_host_t* self,
-      struct _cef_navigation_entry_visitor_t* visitor, int current_only);
+  void(CEF_CALLBACK* get_navigation_entries)(
+      struct _cef_browser_host_t* self,
+      struct _cef_navigation_entry_visitor_t* visitor,
+      int current_only);

  ///
  // Set whether mouse cursor change is disabled.
  ///
  void(CEF_CALLBACK* set_mouse_cursor_change_disabled)(
-      struct _cef_browser_host_t* self, int disabled);
+      struct _cef_browser_host_t* self,
+      int disabled);

  ///
  // Returns true (1) if mouse cursor change is disabled.
@@ -557,16 +580,21 @@ typedef struct _cef_browser_host_t {
  // Send a mouse click event to the browser. The |x| and |y| coordinates are
  // relative to the upper-left corner of the view.
  ///
-  void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_host_t* self,
-      const struct _cef_mouse_event_t* event, cef_mouse_button_type_t type,
-      int mouseUp, int clickCount);
+  void(CEF_CALLBACK* send_mouse_click_event)(
+      struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event,
+      cef_mouse_button_type_t type,
+      int mouseUp,
+      int clickCount);

  ///
  // Send a mouse move event to the browser. The |x| and |y| coordinates are
  // relative to the upper-left corner of the view.
  ///
-  void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_host_t* self,
-      const struct _cef_mouse_event_t* event, int mouseLeave);
+  void(CEF_CALLBACK* send_mouse_move_event)(
+      struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event,
+      int mouseLeave);

  ///
  // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
@@ -575,8 +603,11 @@ typedef struct _cef_browser_host_t {
  // In order to scroll inside select popups with window rendering disabled
  // cef_render_handler_t::GetScreenPoint should be implemented properly.
  ///
-  void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_host_t* self,
-      const struct _cef_mouse_event_t* event, int deltaX, int deltaY);
+  void(CEF_CALLBACK* send_mouse_wheel_event)(
+      struct _cef_browser_host_t* self,
+      const struct _cef_mouse_event_t* event,
+      int deltaX,
+      int deltaY);

  ///
  // Send a focus event to the browser.
@@ -587,8 +618,7 @@ typedef struct _cef_browser_host_t {
  ///
  // Send a capture lost event to the browser.
  ///
-  void (CEF_CALLBACK *send_capture_lost_event)(
-      struct _cef_browser_host_t* self);
+  void(CEF_CALLBACK* send_capture_lost_event)(struct _cef_browser_host_t* self);

  ///
  // Notify the browser that the window hosting it is about to be moved or
@@ -615,7 +645,8 @@ typedef struct _cef_browser_host_t {
  // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
  ///
  void(CEF_CALLBACK* set_windowless_frame_rate)(
-      struct _cef_browser_host_t* self, int frame_rate);
+      struct _cef_browser_host_t* self,
+      int frame_rate);

  ///
  // Begins a new composition or updates the existing composition. Blink has a
@@ -640,8 +671,10 @@ typedef struct _cef_browser_host_t {
  //
  // This function is only used when window rendering is disabled.
  ///
-  void (CEF_CALLBACK *ime_set_composition)(struct _cef_browser_host_t* self,
-      const cef_string_t* text, size_t underlinesCount,
+  void(CEF_CALLBACK* ime_set_composition)(
+      struct _cef_browser_host_t* self,
+      const cef_string_t* text,
+      size_t underlinesCount,
      cef_composition_underline_t const* underlines,
      const cef_range_t* replacement_range,
      const cef_range_t* selection_range);
@@ -656,7 +689,8 @@ typedef struct _cef_browser_host_t {
  // used when window rendering is disabled.
  ///
  void(CEF_CALLBACK* ime_commit_text)(struct _cef_browser_host_t* self,
-      const cef_string_t* text, const cef_range_t* replacement_range,
+                                      const cef_string_t* text,
+                                      const cef_range_t* replacement_range,
                                      int relative_cursor_pos);

  ///
@@ -666,7 +700,8 @@ typedef struct _cef_browser_host_t {
  // function is only used when window rendering is disabled.
  ///
  void(CEF_CALLBACK* ime_finish_composing_text)(
-      struct _cef_browser_host_t* self, int keep_selection);
+      struct _cef_browser_host_t* self,
+      int keep_selection);

  ///
  // Cancels the existing composition and discards the composition node contents
@@ -684,7 +719,8 @@ typedef struct _cef_browser_host_t {
  // cef_render_handler_t::StartDragging). This function is only used when
  // window rendering is disabled.
  ///
-  void (CEF_CALLBACK *drag_target_drag_enter)(struct _cef_browser_host_t* self,
+  void(CEF_CALLBACK* drag_target_drag_enter)(
+      struct _cef_browser_host_t* self,
      struct _cef_drag_data_t* drag_data,
      const struct _cef_mouse_event_t* event,
      cef_drag_operations_mask_t allowed_ops);
@@ -695,7 +731,8 @@ typedef struct _cef_browser_host_t {
  // DragTargetDragLeave/DragTargetDrop). This function is only used when window
  // rendering is disabled.
  ///
-  void (CEF_CALLBACK *drag_target_drag_over)(struct _cef_browser_host_t* self,
+  void(CEF_CALLBACK* drag_target_drag_over)(
+      struct _cef_browser_host_t* self,
      const struct _cef_mouse_event_t* event,
      cef_drag_operations_mask_t allowed_ops);

@@ -726,7 +763,9 @@ typedef struct _cef_browser_host_t {
  // disabled.
  ///
  void(CEF_CALLBACK* drag_source_ended_at)(struct _cef_browser_host_t* self,
-      int x, int y, cef_drag_operations_mask_t op);
+                                           int x,
+                                           int y,
+                                           cef_drag_operations_mask_t op);

  ///
  // Call this function when the drag operation started by a
@@ -745,8 +784,35 @@ typedef struct _cef_browser_host_t {
  ///
  struct _cef_navigation_entry_t*(CEF_CALLBACK* get_visible_navigation_entry)(
      struct _cef_browser_host_t* self);
-} cef_browser_host_t;

+  ///
+  // Set accessibility state for all frames. |accessibility_state| may be
+  // default, enabled or disabled. If |accessibility_state| is STATE_DEFAULT
+  // then accessibility will be disabled by default and the state may be further
+  // controlled with the "force-renderer-accessibility" and "disable-renderer-
+  // accessibility" command-line switches. If |accessibility_state| is
+  // STATE_ENABLED then accessibility will be enabled. If |accessibility_state|
+  // is STATE_DISABLED then accessibility will be completely disabled.
+  //
+  // For windowed browsers accessibility will be enabled in Complete mode (which
+  // corresponds to kAccessibilityModeComplete in Chromium). In this mode all
+  // platform accessibility objects will be created and managed by Chromium's
+  // internal implementation. The client needs only to detect the screen reader
+  // and call this function appropriately. For example, on macOS the client can
+  // handle the @"AXEnhancedUserStructure" accessibility attribute to detect
+  // VoiceOver state changes and on Windows the client can handle WM_GETOBJECT
+  // with OBJID_CLIENT to detect accessibility readers.
+  //
+  // For windowless browsers accessibility will be enabled in TreeOnly mode
+  // (which corresponds to kAccessibilityModeWebContentsOnly in Chromium). In
+  // this mode renderer accessibility is enabled, the full tree is computed, and
+  // events are passed to CefAccessibiltyHandler, but platform accessibility
+  // objects are not created. The client may implement platform accessibility
+  // objects using CefAccessibiltyHandler callbacks if desired.
+  ///
+  void(CEF_CALLBACK* set_accessibility_state)(struct _cef_browser_host_t* self,
+                                              cef_state_t accessibility_state);
+} cef_browser_host_t;

 ///
 // Create a new browser window using the window parameters specified by
@@ -756,8 +822,10 @@ typedef struct _cef_browser_host_t {
 // thread and will not block.
 ///
 CEF_EXPORT int cef_browser_host_create_browser(
-    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
-    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    const cef_window_info_t* windowInfo,
+    struct _cef_client_t* client,
+    const cef_string_t* url,
+    const struct _cef_browser_settings_t* settings,
    struct _cef_request_context_t* request_context);

 ///
@@ -766,11 +834,12 @@ CEF_EXPORT int cef_browser_host_create_browser(
 // used. This function can only be called on the browser process UI thread.
 ///
 CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
-    const cef_window_info_t* windowInfo, struct _cef_client_t* client,
-    const cef_string_t* url, const struct _cef_browser_settings_t* settings,
+    const cef_window_info_t* windowInfo,
+    struct _cef_client_t* client,
+    const cef_string_t* url,
+    const struct _cef_browser_settings_t* settings,
    struct _cef_request_context_t* request_context);

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_browser_process_handler_capi.h
+++ b/include/capi/cef_browser_process_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=0868c7d129e35c38b207b1066fd5eba0c1eef45c$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
@@ -47,7 +49,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to implement browser process callbacks. The functions of this
 // structure will be called on the browser process main thread unless otherwise
@@ -57,7 +58,7 @@ typedef struct _cef_browser_process_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called on the browser process UI thread immediately after the CEF context
@@ -109,10 +110,10 @@ typedef struct _cef_browser_process_handler_t {
  // cancelled.
  ///
  void(CEF_CALLBACK* on_schedule_message_pump_work)(
-      struct _cef_browser_process_handler_t* self, int64 delay_ms);
+      struct _cef_browser_process_handler_t* self,
+      int64 delay_ms);
 } cef_browser_process_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_callback_capi.h
+++ b/include/capi/cef_callback_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=68de2255fd429696d62115786fc480f1d5f9882b$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Generic callback structure used for asynchronous continuation.
 ///
@@ -52,7 +53,7 @@ typedef struct _cef_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue processing.
@@ -65,7 +66,6 @@ typedef struct _cef_callback_t {
  void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self);
 } cef_callback_t;

-
 ///
 // Generic callback structure used for asynchronous completion.
 ///
@@ -73,7 +73,7 @@ typedef struct _cef_completion_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be called once the task is complete.
@@ -81,7 +81,6 @@ typedef struct _cef_completion_callback_t {
  void(CEF_CALLBACK* on_complete)(struct _cef_completion_callback_t* self);
 } cef_completion_callback_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_client_capi.h
+++ b/include/capi/cef_client_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=7f554250e73537ece3f8f67310c23e718f91d41b$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@@ -59,7 +61,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to provide handler implementations.
 ///
@@ -67,7 +68,7 @@ typedef struct _cef_client_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Return the handler for context menus. If no handler is provided the default
@@ -163,12 +164,13 @@ typedef struct _cef_client_t {
  // (1) if the message was handled or false (0) otherwise. Do not keep a
  // reference to or attempt to access the message outside of this callback.
  ///
-  int (CEF_CALLBACK *on_process_message_received)(struct _cef_client_t* self,
-      struct _cef_browser_t* browser, cef_process_id_t source_process,
+  int(CEF_CALLBACK* on_process_message_received)(
+      struct _cef_client_t* self,
+      struct _cef_browser_t* browser,
+      cef_process_id_t source_process,
      struct _cef_process_message_t* message);
 } cef_client_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_command_line_capi.h
+++ b/include/capi/cef_command_line_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=b917030321dc11ddfc8d8939239dda7952d2f955$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to create and/or parse command line arguments. Arguments with
 // '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
@@ -59,7 +60,7 @@ typedef struct _cef_command_line_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is valid. Do not call any other functions
@@ -85,7 +86,8 @@ typedef struct _cef_command_line_t {
  // supported on non-Windows platforms.
  ///
  void(CEF_CALLBACK* init_from_argv)(struct _cef_command_line_t* self,
-      int argc, const char* const* argv);
+                                     int argc,
+                                     const char* const* argv);

  ///
  // Initialize the command line with the string returned by calling
@@ -145,7 +147,8 @@ typedef struct _cef_command_line_t {
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
  cef_string_userfree_t(CEF_CALLBACK* get_switch_value)(
-      struct _cef_command_line_t* self, const cef_string_t* name);
+      struct _cef_command_line_t* self,
+      const cef_string_t* name);

  ///
  // Returns the map of switch names and values. If a switch has no value an
@@ -164,8 +167,8 @@ typedef struct _cef_command_line_t {
  ///
  // Add a switch with the specified value to the end of the command line.
  ///
-  void (CEF_CALLBACK *append_switch_with_value)(
-      struct _cef_command_line_t* self, const cef_string_t* name,
+  void(CEF_CALLBACK* append_switch_with_value)(struct _cef_command_line_t* self,
+                                               const cef_string_t* name,
                                               const cef_string_t* value);

  ///
@@ -193,7 +196,6 @@ typedef struct _cef_command_line_t {
                                      const cef_string_t* wrapper);
 } cef_command_line_t;

-
 ///
 // Create a new cef_command_line_t instance.
 ///
@@ -205,7 +207,6 @@ CEF_EXPORT cef_command_line_t* cef_command_line_create();
 ///
 CEF_EXPORT cef_command_line_t* cef_command_line_get_global();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_context_menu_handler_capi.h
+++ b/include/capi/cef_context_menu_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=2e295ba277083061103147a400bc30f78e6a94f5$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@@ -56,14 +58,15 @@ typedef struct _cef_run_context_menu_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Complete context menu display by selecting the specified |command_id| and
  // |event_flags|.
  ///
  void(CEF_CALLBACK* cont)(struct _cef_run_context_menu_callback_t* self,
-      int command_id, cef_event_flags_t event_flags);
+                           int command_id,
+                           cef_event_flags_t event_flags);

  ///
  // Cancel context menu display.
@@ -71,7 +74,6 @@ 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;

-
 ///
 // Implement this structure to handle context menu events. The functions of this
 // structure will be called on the UI thread.
@@ -80,7 +82,7 @@ typedef struct _cef_context_menu_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called before a context menu is displayed. |params| provides information
@@ -90,8 +92,10 @@ typedef struct _cef_context_menu_handler_t {
  // |model| outside of this callback.
  ///
  void(CEF_CALLBACK* on_before_context_menu)(
-      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_context_menu_params_t* params,
      struct _cef_menu_model_t* model);

  ///
@@ -102,8 +106,10 @@ typedef struct _cef_context_menu_handler_t {
  // selected command ID. For default display return false (0). Do not keep
  // references to |params| or |model| outside of this callback.
  ///
-  int (CEF_CALLBACK *run_context_menu)(struct _cef_context_menu_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+  int(CEF_CALLBACK* run_context_menu)(
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
      struct _cef_context_menu_params_t* params,
      struct _cef_menu_model_t* model,
      struct _cef_run_context_menu_callback_t* callback);
@@ -118,20 +124,23 @@ typedef struct _cef_context_menu_handler_t {
  // this callback.
  ///
  int(CEF_CALLBACK* on_context_menu_command)(
-      struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
-      int command_id, cef_event_flags_t event_flags);
+      struct _cef_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_context_menu_params_t* params,
+      int command_id,
+      cef_event_flags_t event_flags);

  ///
  // Called when the context menu is dismissed irregardless of whether the menu
  // was NULL 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_context_menu_handler_t* self,
+      struct _cef_browser_t* browser,
      struct _cef_frame_t* frame);
 } cef_context_menu_handler_t;

-
 ///
 // Provides information about the context menu state. The ethods of this
 // structure can only be accessed on browser process the UI thread.
@@ -140,7 +149,7 @@ typedef struct _cef_context_menu_params_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the X coordinate of the mouse where the context menu was invoked.
@@ -257,7 +266,8 @@ typedef struct _cef_context_menu_params_t {
  // is one.
  ///
  int(CEF_CALLBACK* get_dictionary_suggestions)(
-      struct _cef_context_menu_params_t* self, cef_string_list_t suggestions);
+      struct _cef_context_menu_params_t* self,
+      cef_string_list_t suggestions);

  ///
  // Returns true (1) if the context menu was invoked on an editable node.
@@ -291,7 +301,6 @@ typedef struct _cef_context_menu_params_t {
  int(CEF_CALLBACK* is_pepper_menu)(struct _cef_context_menu_params_t* self);
 } cef_context_menu_params_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_cookie_capi.h
+++ b/include/capi/cef_cookie_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=c2bf8084385f3c795ae7494da6970a0a61b96ac6$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
@@ -57,7 +59,7 @@ typedef struct _cef_cookie_manager_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Set the schemes supported by this manager. The default schemes ("http",
@@ -65,8 +67,10 @@ typedef struct _cef_cookie_manager_t {
  // NULL it will be executed asnychronously on the IO thread after the change
  // has been applied. Must be called before any cookies are accessed.
  ///
-  void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self,
-      cef_string_list_t schemes, struct _cef_completion_callback_t* callback);
+  void(CEF_CALLBACK* set_supported_schemes)(
+      struct _cef_cookie_manager_t* self,
+      cef_string_list_t schemes,
+      struct _cef_completion_callback_t* callback);

  ///
  // Visit all cookies on the IO thread. The returned cookies are ordered by
@@ -84,7 +88,8 @@ typedef struct _cef_cookie_manager_t {
  // Returns false (0) if cookies cannot be accessed.
  ///
  int(CEF_CALLBACK* visit_url_cookies)(struct _cef_cookie_manager_t* self,
-      const cef_string_t* url, int includeHttpOnly,
+                                       const cef_string_t* url,
+                                       int includeHttpOnly,
                                       struct _cef_cookie_visitor_t* visitor);

  ///
@@ -97,7 +102,8 @@ typedef struct _cef_cookie_manager_t {
  // false (0) if an invalid URL is specified or if cookies cannot be accessed.
  ///
  int(CEF_CALLBACK* set_cookie)(struct _cef_cookie_manager_t* self,
-      const cef_string_t* url, const struct _cef_cookie_t* cookie,
+                                const cef_string_t* url,
+                                const struct _cef_cookie_t* cookie,
                                struct _cef_set_cookie_callback_t* callback);

  ///
@@ -111,8 +117,10 @@ typedef struct _cef_cookie_manager_t {
  // or if cookies cannot be accessed. Cookies can alternately be deleted using
  // the Visit*Cookies() functions.
  ///
-  int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self,
-      const cef_string_t* url, const cef_string_t* cookie_name,
+  int(CEF_CALLBACK* delete_cookies)(
+      struct _cef_cookie_manager_t* self,
+      const cef_string_t* url,
+      const cef_string_t* cookie_name,
      struct _cef_delete_cookies_callback_t* callback);

  ///
@@ -125,8 +133,10 @@ typedef struct _cef_cookie_manager_t {
  // asnychronously on the IO thread after the manager's storage has been
  // initialized. Returns false (0) if cookies cannot be accessed.
  ///
-  int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self,
-      const cef_string_t* path, int persist_session_cookies,
+  int(CEF_CALLBACK* set_storage_path)(
+      struct _cef_cookie_manager_t* self,
+      const cef_string_t* path,
+      int persist_session_cookies,
      struct _cef_completion_callback_t* callback);

  ///
@@ -138,7 +148,6 @@ typedef struct _cef_cookie_manager_t {
                                 struct _cef_completion_callback_t* callback);
 } cef_cookie_manager_t;

-
 ///
 // Returns the global cookie manager. By default data will be stored at
 // CefSettings.cache_path if specified or in memory otherwise. If |callback| is
@@ -160,10 +169,10 @@ CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(
 // manager's storage has been initialized.
 ///
 CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
-    const cef_string_t* path, int persist_session_cookies,
+    const cef_string_t* path,
+    int persist_session_cookies,
    struct _cef_completion_callback_t* callback);

-
 ///
 // Structure to implement for visiting cookie values. The functions of this
 // structure will always be called on the IO thread.
@@ -172,7 +181,7 @@ typedef struct _cef_cookie_visitor_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be called once for each cookie. |count| is the 0-based
@@ -182,11 +191,12 @@ typedef struct _cef_cookie_visitor_t {
  // called if no cookies are found.
  ///
  int(CEF_CALLBACK* visit)(struct _cef_cookie_visitor_t* self,
-      const struct _cef_cookie_t* cookie, int count, int total,
+                           const struct _cef_cookie_t* cookie,
+                           int count,
+                           int total,
                           int* deleteCookie);
 } cef_cookie_visitor_t;

-
 ///
 // Structure to implement to be notified of asynchronous completion via
 // cef_cookie_manager_t::set_cookie().
@@ -195,7 +205,7 @@ typedef struct _cef_set_cookie_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be called upon completion. |success| will be true (1) if
@@ -205,7 +215,6 @@ typedef struct _cef_set_cookie_callback_t {
                                  int success);
 } cef_set_cookie_callback_t;

-
 ///
 // Structure to implement to be notified of asynchronous completion via
 // cef_cookie_manager_t::delete_cookies().
@@ -214,7 +223,7 @@ typedef struct _cef_delete_cookies_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be called upon completion. |num_deleted| will be the
@@ -224,7 +233,6 @@ typedef struct _cef_delete_cookies_callback_t {
                                  int num_deleted);
 } cef_delete_cookies_callback_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_crash_util_capi.h
+++ b/include/capi/cef_crash_util_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=8b7354f5a1ad6b255d77e477c64374b927f4fe28$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Crash reporting is configured using an INI-style config file named
 // "crash_reporter.cfg". On Windows and Linux this file must be placed next to
--- a/include/capi/cef_dialog_handler_capi.h
+++ b/include/capi/cef_dialog_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=b8a44f4f624ba51107d06ff3d1a7934e83765786$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure for asynchronous continuation of file dialog requests.
 ///
@@ -53,7 +54,7 @@ typedef struct _cef_file_dialog_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue the file selection. |selected_accept_filter| should be the 0-based
@@ -63,7 +64,8 @@ typedef struct _cef_file_dialog_callback_t {
  // 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);
+                           int selected_accept_filter,
+                           cef_string_list_t file_paths);

  ///
  // Cancel the file selection.
@@ -71,7 +73,6 @@ typedef struct _cef_file_dialog_callback_t {
  void(CEF_CALLBACK* cancel)(struct _cef_file_dialog_callback_t* self);
 } cef_file_dialog_callback_t;

-
 ///
 // Implement this structure to handle dialog events. The functions of this
 // structure will be called on the browser process UI thread.
@@ -80,7 +81,7 @@ typedef struct _cef_dialog_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called to run a file chooser dialog. |mode| represents the type of dialog
@@ -97,14 +98,17 @@ typedef struct _cef_dialog_handler_t {
  // return true (1) and execute |callback| either inline or at a later time. To
  // display the default dialog return false (0).
  ///
-  int (CEF_CALLBACK *on_file_dialog)(struct _cef_dialog_handler_t* self,
-      struct _cef_browser_t* browser, cef_file_dialog_mode_t mode,
-      const cef_string_t* title, const cef_string_t* default_file_path,
-      cef_string_list_t accept_filters, int selected_accept_filter,
+  int(CEF_CALLBACK* on_file_dialog)(
+      struct _cef_dialog_handler_t* self,
+      struct _cef_browser_t* browser,
+      cef_file_dialog_mode_t mode,
+      const cef_string_t* title,
+      const cef_string_t* default_file_path,
+      cef_string_list_t accept_filters,
+      int selected_accept_filter,
      struct _cef_file_dialog_callback_t* callback);
 } cef_dialog_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_display_handler_capi.h
+++ b/include/capi/cef_display_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=f0f3fd4cab00c0eb11956e674a111cb30d3af100$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to browser display state.
 // The functions of this structure will be called on the UI thread.
@@ -55,26 +56,29 @@ typedef struct _cef_display_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when a frame's address has changed.
  ///
  void(CEF_CALLBACK* on_address_change)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+                                        struct _cef_browser_t* browser,
+                                        struct _cef_frame_t* frame,
                                        const cef_string_t* url);

  ///
  // Called when the page title changes.
  ///
  void(CEF_CALLBACK* on_title_change)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* title);
+                                      struct _cef_browser_t* browser,
+                                      const cef_string_t* title);

  ///
  // Called when the page icon changes.
  ///
  void(CEF_CALLBACK* on_favicon_urlchange)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, cef_string_list_t icon_urls);
+                                           struct _cef_browser_t* browser,
+                                           cef_string_list_t icon_urls);

  ///
  // Called when web content in the page has toggled fullscreen mode. If
@@ -84,7 +88,8 @@ typedef struct _cef_display_handler_t {
  // responsible for resizing the browser if desired.
  ///
  void(CEF_CALLBACK* on_fullscreen_mode_change)(
-      struct _cef_display_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_display_handler_t* self,
+      struct _cef_browser_t* browser,
      int fullscreen);

  ///
@@ -96,25 +101,28 @@ typedef struct _cef_display_handler_t {
  // for drawing tooltips and the return value is ignored.
  ///
  int(CEF_CALLBACK* on_tooltip)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, cef_string_t* text);
+                                struct _cef_browser_t* browser,
+                                cef_string_t* text);

  ///
  // Called when the browser receives a status message. |value| contains the
  // text that will be displayed in the status message.
  ///
  void(CEF_CALLBACK* on_status_message)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* value);
+                                        struct _cef_browser_t* browser,
+                                        const cef_string_t* value);

  ///
  // Called to display a console message. Return true (1) to stop the message
  // from being output to the console.
  ///
  int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* message,
-      const cef_string_t* source, int line);
+                                        struct _cef_browser_t* browser,
+                                        const cef_string_t* message,
+                                        const cef_string_t* source,
+                                        int line);
 } cef_display_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_dom_capi.h
+++ b/include/capi/cef_dom_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=db82ff508cb1b4a03001b8b30bc5126186ee1bd2$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
@@ -55,7 +57,7 @@ typedef struct _cef_domvisitor_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method executed for visiting the DOM. The document object passed to this
@@ -68,7 +70,6 @@ typedef struct _cef_domvisitor_t {
                            struct _cef_domdocument_t* document);
 } cef_domvisitor_t;

-
 ///
 // Structure used to represent a DOM document. The functions of this structure
 // should only be called on the render process main thread thread.
@@ -77,7 +78,7 @@ typedef struct _cef_domdocument_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the document type.
@@ -114,7 +115,8 @@ typedef struct _cef_domdocument_t {
  // Returns the document element with the specified ID value.
  ///
  struct _cef_domnode_t*(CEF_CALLBACK* get_element_by_id)(
-      struct _cef_domdocument_t* self, const cef_string_t* id);
+      struct _cef_domdocument_t* self,
+      const cef_string_t* id);

  ///
  // Returns the node that currently has keyboard focus.
@@ -165,10 +167,10 @@ typedef struct _cef_domdocument_t {
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
  cef_string_userfree_t(CEF_CALLBACK* get_complete_url)(
-      struct _cef_domdocument_t* self, const cef_string_t* partialURL);
+      struct _cef_domdocument_t* self,
+      const cef_string_t* partialURL);
 } cef_domdocument_t;

-
 ///
 // Structure used to represent a DOM node. The functions of this structure
 // should only be called on the render process main thread.
@@ -177,7 +179,7 @@ typedef struct _cef_domnode_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the type for this node.
@@ -252,8 +254,7 @@ typedef struct _cef_domnode_t {
  ///
  // Returns the parent node.
  ///
-  struct _cef_domnode_t* (CEF_CALLBACK *get_parent)(
-      struct _cef_domnode_t* self);
+  struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self);

  ///
  // Returns the previous sibling node.
@@ -284,7 +285,6 @@ typedef struct _cef_domnode_t {
  struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)(
      struct _cef_domnode_t* self);

-
  // The following functions are valid only for element nodes.

  ///
@@ -310,7 +310,8 @@ typedef struct _cef_domnode_t {
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
  cef_string_userfree_t(CEF_CALLBACK* get_element_attribute)(
-      struct _cef_domnode_t* self, const cef_string_t* attrName);
+      struct _cef_domnode_t* self,
+      const cef_string_t* attrName);

  ///
  // Returns a map of all element attributes.
@@ -323,7 +324,8 @@ typedef struct _cef_domnode_t {
  // on success.
  ///
  int(CEF_CALLBACK* set_element_attribute)(struct _cef_domnode_t* self,
-      const cef_string_t* attrName, const cef_string_t* value);
+                                           const cef_string_t* attrName,
+                                           const cef_string_t* value);

  ///
  // Returns the inner text of the element.
@@ -338,7 +340,6 @@ typedef struct _cef_domnode_t {
  cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self);
 } cef_domnode_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_download_handler_capi.h
+++ b/include/capi/cef_download_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=4475f7e48898bdef8051c849873fb2528320cd9c$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure used to asynchronously continue a download.
 ///
@@ -54,7 +55,7 @@ typedef struct _cef_before_download_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Call to continue the download. Set |download_path| to the full file path
@@ -63,10 +64,10 @@ typedef struct _cef_before_download_callback_t {
  // (1) if you do wish to show the default "Save As" dialog.
  ///
  void(CEF_CALLBACK* cont)(struct _cef_before_download_callback_t* self,
-      const cef_string_t* download_path, int show_dialog);
+                           const cef_string_t* download_path,
+                           int show_dialog);
 } cef_before_download_callback_t;

-
 ///
 // Callback structure used to asynchronously cancel a download.
 ///
@@ -74,7 +75,7 @@ typedef struct _cef_download_item_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Call to cancel the download.
@@ -92,7 +93,6 @@ typedef struct _cef_download_item_callback_t {
  void(CEF_CALLBACK* resume)(struct _cef_download_item_callback_t* self);
 } cef_download_item_callback_t;

-
 ///
 // Structure used to handle file downloads. The functions of this structure will
 // called on the browser process UI thread.
@@ -101,7 +101,7 @@ typedef struct _cef_download_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called before a download begins. |suggested_name| is the suggested name for
@@ -110,7 +110,8 @@ typedef struct _cef_download_handler_t {
  // download if desired. Do not keep a reference to |download_item| outside of
  // this function.
  ///
-  void (CEF_CALLBACK *on_before_download)(struct _cef_download_handler_t* self,
+  void(CEF_CALLBACK* on_before_download)(
+      struct _cef_download_handler_t* self,
      struct _cef_browser_t* browser,
      struct _cef_download_item_t* download_item,
      const cef_string_t* suggested_name,
@@ -123,13 +124,13 @@ typedef struct _cef_download_handler_t {
  // download if desired. Do not keep a reference to |download_item| outside of
  // this function.
  ///
-  void (CEF_CALLBACK *on_download_updated)(struct _cef_download_handler_t* self,
+  void(CEF_CALLBACK* on_download_updated)(
+      struct _cef_download_handler_t* self,
      struct _cef_browser_t* browser,
      struct _cef_download_item_t* download_item,
      struct _cef_download_item_callback_t* callback);
 } cef_download_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_download_item_capi.h
+++ b/include/capi/cef_download_item_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=cc669703d613f5a6a5bae95030835dc99f55a6fa$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to represent a download item.
 ///
@@ -52,7 +53,7 @@ typedef struct _cef_download_item_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is valid. Do not call any other functions
@@ -154,7 +155,6 @@ typedef struct _cef_download_item_t {
      struct _cef_download_item_t* self);
 } cef_download_item_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_drag_data_capi.h
+++ b/include/capi/cef_drag_data_capi.h
@@ -33,19 +33,21 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=a4b5264c1e685cad86203772631460684ee7820d$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
 #pragma once

 #include "include/capi/cef_base_capi.h"
+#include "include/capi/cef_image_capi.h"
 #include "include/capi/cef_stream_capi.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-
 ///
 // Structure used to represent drag data. The functions of this structure may be
 // called on any thread.
@@ -54,7 +56,7 @@ typedef struct _cef_drag_data_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns a copy of the current object.
@@ -194,16 +196,31 @@ typedef struct _cef_drag_data_t {
  // Add a file that is being dragged into the webview.
  ///
  void(CEF_CALLBACK* add_file)(struct _cef_drag_data_t* self,
-      const cef_string_t* path, const cef_string_t* display_name);
-} cef_drag_data_t;
+                               const cef_string_t* path,
+                               const cef_string_t* display_name);

+  ///
+  // Get the image representation of drag data. May return NULL if no image
+  // representation is available.
+  ///
+  struct _cef_image_t*(CEF_CALLBACK* get_image)(struct _cef_drag_data_t* self);
+
+  ///
+  // Get the image hotspot (drag start location relative to image dimensions).
+  ///
+  cef_point_t(CEF_CALLBACK* get_image_hotspot)(struct _cef_drag_data_t* self);
+
+  ///
+  // Returns true (1) if an image representation of drag data is available.
+  ///
+  int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self);
+} cef_drag_data_t;

 ///
 // Create a new cef_drag_data_t object.
 ///
 CEF_EXPORT cef_drag_data_t* cef_drag_data_create();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_drag_handler_capi.h
+++ b/include/capi/cef_drag_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=c557dad9522f4bd4c6b3295d149c6b893fc18d52$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to dragging. The functions
 // of this structure will be called on the UI thread.
@@ -55,7 +56,7 @@ typedef struct _cef_drag_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when an external drag event enters the browser window. |dragData|
@@ -64,7 +65,8 @@ typedef struct _cef_drag_handler_t {
  // to cancel the drag event.
  ///
  int(CEF_CALLBACK* on_drag_enter)(struct _cef_drag_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData,
+                                   struct _cef_browser_t* browser,
+                                   struct _cef_drag_data_t* dragData,
                                   cef_drag_operations_mask_t mask);

  ///
@@ -75,11 +77,12 @@ typedef struct _cef_drag_handler_t {
  // this function will be called with an NULL vector.
  ///
  void(CEF_CALLBACK* on_draggable_regions_changed)(
-      struct _cef_drag_handler_t* self, struct _cef_browser_t* browser,
-      size_t regionsCount, cef_draggable_region_t const* regions);
+      struct _cef_drag_handler_t* self,
+      struct _cef_browser_t* browser,
+      size_t regionsCount,
+      cef_draggable_region_t const* regions);
 } cef_drag_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_file_util_capi.h
+++ b/include/capi/cef_file_util_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=1c02b57893a3f78c436bc2ab66c63753edfb174a$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Creates a directory and all parent directories if they don't already exist.
 // Returns true (1) on successful creation or if the directory already exists.
@@ -82,7 +83,8 @@ CEF_EXPORT int cef_create_new_temp_directory(const cef_string_t* prefix,
 // or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_create_temp_directory_in_directory(
-    const cef_string_t* base_dir, const cef_string_t* prefix,
+    const cef_string_t* base_dir,
+    const cef_string_t* prefix,
    cef_string_t* new_dir);

 ///
@@ -109,7 +111,18 @@ CEF_EXPORT int cef_delete_file(const cef_string_t* path, int recursive);
 // or IO threads is not allowed.
 ///
 CEF_EXPORT int cef_zip_directory(const cef_string_t* src_dir,
-    const cef_string_t* dest_file, int include_hidden_files);
+                                 const cef_string_t* dest_file,
+                                 int include_hidden_files);
+
+///
+// Loads the existing "Certificate Revocation Lists" file that is managed by
+// Google Chrome. This file can generally be found in Chrome's User Data
+// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on
+// Windows) and is updated periodically by Chrome's component updater service.
+// Must be called in the browser process after the context has been initialized.
+// See https://dev.chromium.org/Home/chromium-security/crlsets for background.
+///
+CEF_EXPORT void cef_load_crlsets_file(const cef_string_t* path);

 #ifdef __cplusplus
 }
--- a/include/capi/cef_find_handler_capi.h
+++ b/include/capi/cef_find_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=975114b079fa271fecbf31ef160974941faed8a4$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to find results. The
 // functions of this structure will be called on the UI thread.
@@ -54,7 +55,7 @@ typedef struct _cef_find_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called to report find results returned by cef_browser_host_t::find().
@@ -65,12 +66,14 @@ typedef struct _cef_find_handler_t {
  // this is the last find notification.
  ///
  void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
-      struct _cef_browser_t* browser, int identifier, int count,
-      const cef_rect_t* selectionRect, int activeMatchOrdinal,
+                                     struct _cef_browser_t* browser,
+                                     int identifier,
+                                     int count,
+                                     const cef_rect_t* selectionRect,
+                                     int activeMatchOrdinal,
                                     int finalUpdate);
 } cef_find_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_focus_handler_capi.h
+++ b/include/capi/cef_focus_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=bed1f7b94e060b83e3f22eb84ce1274f2d10b3e6$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
@@ -47,7 +49,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to focus. The functions of
 // this structure will be called on the UI thread.
@@ -56,7 +57,7 @@ typedef struct _cef_focus_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when the browser component is about to loose focus. For instance, if
@@ -65,7 +66,8 @@ typedef struct _cef_focus_handler_t {
  // false (0) if the browser is giving focus to the previous component.
  ///
  void(CEF_CALLBACK* on_take_focus)(struct _cef_focus_handler_t* self,
-      struct _cef_browser_t* browser, int next);
+                                    struct _cef_browser_t* browser,
+                                    int next);

  ///
  // Called when the browser component is requesting focus. |source| indicates
@@ -73,7 +75,8 @@ typedef struct _cef_focus_handler_t {
  // focus to be set or true (1) to cancel setting the focus.
  ///
  int(CEF_CALLBACK* on_set_focus)(struct _cef_focus_handler_t* self,
-      struct _cef_browser_t* browser, cef_focus_source_t source);
+                                  struct _cef_browser_t* browser,
+                                  cef_focus_source_t source);

  ///
  // Called when the browser component has received focus.
@@ -82,7 +85,6 @@ typedef struct _cef_focus_handler_t {
                                   struct _cef_browser_t* browser);
 } cef_focus_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_frame_capi.h
+++ b/include/capi/cef_frame_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=c1457ef21c14c40422b19b681121283eae3e9d70$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
@@ -61,7 +63,7 @@ typedef struct _cef_frame_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // True if this object is currently attached to a valid frame.
@@ -142,7 +144,8 @@ typedef struct _cef_frame_t {
  // link clicks and web security restrictions may not behave as expected.
  ///
  void(CEF_CALLBACK* load_string)(struct _cef_frame_t* self,
-      const cef_string_t* string_val, const cef_string_t* url);
+                                  const cef_string_t* string_val,
+                                  const cef_string_t* url);

  ///
  // Execute a string of JavaScript code in this frame. The |script_url|
@@ -152,7 +155,8 @@ typedef struct _cef_frame_t {
  // reporting.
  ///
  void(CEF_CALLBACK* execute_java_script)(struct _cef_frame_t* self,
-      const cef_string_t* code, const cef_string_t* script_url,
+                                          const cef_string_t* code,
+                                          const cef_string_t* script_url,
                                          int start_line);

  ///
@@ -213,7 +217,6 @@ typedef struct _cef_frame_t {
                                struct _cef_domvisitor_t* visitor);
 } cef_frame_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_geolocation_capi.h
+++ b/include/capi/cef_geolocation_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=3ae57ba897d73f3fcccc955c827379746b6203af$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to receive geolocation updates. The functions of
 // this structure will be called on the browser process UI thread.
@@ -53,7 +54,7 @@ typedef struct _cef_get_geolocation_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called with the 'best available' location information or, if the location
@@ -64,7 +65,6 @@ typedef struct _cef_get_geolocation_callback_t {
      const struct _cef_geoposition_t* position);
 } cef_get_geolocation_callback_t;

-
 ///
 // Request a one-time geolocation update. This function bypasses any user
 // permission checks so should only be used by code that is allowed to access
--- a/include/capi/cef_geolocation_handler_capi.h
+++ b/include/capi/cef_geolocation_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=ec60811fcefbe02348f14ecddbe5778ce836bf53$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure used for asynchronous continuation of geolocation
 // permission requests.
@@ -54,16 +55,14 @@ typedef struct _cef_geolocation_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Call to allow or deny geolocation access.
  ///
-  void (CEF_CALLBACK *cont)(struct _cef_geolocation_callback_t* self,
-      int allow);
+  void(CEF_CALLBACK* cont)(struct _cef_geolocation_callback_t* self, int allow);
 } cef_geolocation_callback_t;

-
 ///
 // Implement this structure to handle events related to geolocation permission
 // requests. The functions of this structure will be called on the browser
@@ -73,7 +72,7 @@ typedef struct _cef_geolocation_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when a page requests permission to access geolocation information.
@@ -84,8 +83,10 @@ typedef struct _cef_geolocation_handler_t {
  // request immediately.
  ///
  int(CEF_CALLBACK* on_request_geolocation_permission)(
-      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
-      const cef_string_t* requesting_url, int request_id,
+      struct _cef_geolocation_handler_t* self,
+      struct _cef_browser_t* browser,
+      const cef_string_t* requesting_url,
+      int request_id,
      struct _cef_geolocation_callback_t* callback);

  ///
@@ -93,11 +94,11 @@ typedef struct _cef_geolocation_handler_t {
  // unique ID for the permission request.
  ///
  void(CEF_CALLBACK* on_cancel_geolocation_permission)(
-      struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_geolocation_handler_t* self,
+      struct _cef_browser_t* browser,
      int request_id);
 } cef_geolocation_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_image_capi.h
+++ b/include/capi/cef_image_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=60f904f2f77ce6d89f9fceeeda0050273a3c9e6d$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Container for a single image represented at different scale factors. All
 // image representations should be the same size in density independent pixel
@@ -58,7 +59,7 @@ typedef struct _cef_image_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this Image is NULL.
@@ -79,9 +80,13 @@ typedef struct _cef_image_t {
  // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
  // |color_type| and |alpha_type| values specify the pixel format.
  ///
-  int (CEF_CALLBACK *add_bitmap)(struct _cef_image_t* self, float scale_factor,
-      int pixel_width, int pixel_height, cef_color_type_t color_type,
-      cef_alpha_type_t alpha_type, const void* pixel_data,
+  int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self,
+                                float scale_factor,
+                                int pixel_width,
+                                int pixel_height,
+                                cef_color_type_t color_type,
+                                cef_alpha_type_t alpha_type,
+                                const void* pixel_data,
                                size_t pixel_data_size);

  ///
@@ -89,16 +94,20 @@ typedef struct _cef_image_t {
  // data of size |png_data_size|. Any alpha transparency in the PNG data will
  // be maintained.
  ///
-  int (CEF_CALLBACK *add_png)(struct _cef_image_t* self, float scale_factor,
-      const void* png_data, size_t png_data_size);
+  int(CEF_CALLBACK* add_png)(struct _cef_image_t* self,
+                             float scale_factor,
+                             const void* png_data,
+                             size_t png_data_size);

  ///
  // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
  // image data of size |jpeg_data_size|. The JPEG format does not support
  // transparency so the alpha byte will be set to 0xFF for all pixels.
  ///
-  int (CEF_CALLBACK *add_jpeg)(struct _cef_image_t* self, float scale_factor,
-      const void* jpeg_data, size_t jpeg_data_size);
+  int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self,
+                              float scale_factor,
+                              const void* jpeg_data,
+                              size_t jpeg_data_size);

  ///
  // Returns the image width in density independent pixel (DIP) units.
@@ -130,7 +139,9 @@ typedef struct _cef_image_t {
  // size in pixel coordinates. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* get_representation_info)(struct _cef_image_t* self,
-      float scale_factor, float* actual_scale_factor, int* pixel_width,
+                                             float scale_factor,
+                                             float* actual_scale_factor,
+                                             int* pixel_width,
                                             int* pixel_height);

  ///
@@ -142,9 +153,12 @@ typedef struct _cef_image_t {
  // on failure.
  ///
  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)(
-      struct _cef_image_t* self, float scale_factor,
-      cef_color_type_t color_type, cef_alpha_type_t alpha_type,
-      int* pixel_width, int* pixel_height);
+      struct _cef_image_t* self,
+      float scale_factor,
+      cef_color_type_t color_type,
+      cef_alpha_type_t alpha_type,
+      int* pixel_width,
+      int* pixel_height);

  ///
  // Returns the PNG representation that most closely matches |scale_factor|. If
@@ -155,8 +169,11 @@ typedef struct _cef_image_t {
  // failure.
  ///
  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)(
-      struct _cef_image_t* self, float scale_factor, int with_transparency,
-      int* pixel_width, int* pixel_height);
+      struct _cef_image_t* self,
+      float scale_factor,
+      int with_transparency,
+      int* pixel_width,
+      int* pixel_height);

  ///
  // Returns the JPEG representation that most closely matches |scale_factor|.
@@ -168,18 +185,19 @@ typedef struct _cef_image_t {
  // failure.
  ///
  struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)(
-      struct _cef_image_t* self, float scale_factor, int quality,
-      int* pixel_width, int* pixel_height);
+      struct _cef_image_t* self,
+      float scale_factor,
+      int quality,
+      int* pixel_width,
+      int* pixel_height);
 } cef_image_t;

-
 ///
 // Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
 // to add representations at different scale factors.
 ///
 CEF_EXPORT cef_image_t* cef_image_create();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_jsdialog_handler_capi.h
+++ b/include/capi/cef_jsdialog_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=351cff5a52f29b54d1854d5dfbb1733c8a62797d$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure used for asynchronous continuation of JavaScript dialog
 // requests.
@@ -54,17 +55,17 @@ typedef struct _cef_jsdialog_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue the JS dialog request. Set |success| to true (1) if the OK button
  // was pressed. The |user_input| value should be specified for prompt dialogs.
  ///
-  void (CEF_CALLBACK *cont)(struct _cef_jsdialog_callback_t* self, int success,
+  void(CEF_CALLBACK* cont)(struct _cef_jsdialog_callback_t* self,
+                           int success,
                           const cef_string_t* user_input);
 } cef_jsdialog_callback_t;

-
 ///
 // Implement this structure to handle events related to JavaScript dialogs. The
 // functions of this structure will be called on the UI thread.
@@ -73,7 +74,7 @@ typedef struct _cef_jsdialog_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
@@ -93,10 +94,13 @@ typedef struct _cef_jsdialog_handler_t {
  // dismissed.
  ///
  int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* origin_url,
-      cef_jsdialog_type_t dialog_type, const cef_string_t* message_text,
+                                 struct _cef_browser_t* browser,
+                                 const cef_string_t* origin_url,
+                                 cef_jsdialog_type_t dialog_type,
+                                 const cef_string_t* message_text,
                                 const cef_string_t* default_prompt_text,
-      struct _cef_jsdialog_callback_t* callback, int* suppress_message);
+                                 struct _cef_jsdialog_callback_t* callback,
+                                 int* suppress_message);

  ///
  // Called to run a dialog asking the user if they want to leave a page. Return
@@ -107,8 +111,10 @@ typedef struct _cef_jsdialog_handler_t {
  // dialog is dismissed.
  ///
  int(CEF_CALLBACK* on_before_unload_dialog)(
-      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser,
-      const cef_string_t* message_text, int is_reload,
+      struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser,
+      const cef_string_t* message_text,
+      int is_reload,
      struct _cef_jsdialog_callback_t* callback);

  ///
@@ -117,7 +123,8 @@ typedef struct _cef_jsdialog_handler_t {
  // dialogs are currently pending.
  ///
  void(CEF_CALLBACK* on_reset_dialog_state)(
-      struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser);
+      struct _cef_jsdialog_handler_t* self,
+      struct _cef_browser_t* browser);

  ///
  // Called when the default implementation dialog is closed.
@@ -126,7 +133,6 @@ typedef struct _cef_jsdialog_handler_t {
                                       struct _cef_browser_t* browser);
 } cef_jsdialog_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_keyboard_handler_capi.h
+++ b/include/capi/cef_keyboard_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=07c2a01bb9975fa52fdb287712f8f369557ba755$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to keyboard input. The
 // functions of this structure will be called on the UI thread.
@@ -54,7 +55,7 @@ typedef struct _cef_keyboard_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called before a keyboard event is sent to the renderer. |event| contains
@@ -64,8 +65,10 @@ typedef struct _cef_keyboard_handler_t {
  // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
  ///
  int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self,
-      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
-      cef_event_handle_t os_event, int* is_keyboard_shortcut);
+                                      struct _cef_browser_t* browser,
+                                      const struct _cef_key_event_t* event,
+                                      cef_event_handle_t os_event,
+                                      int* is_keyboard_shortcut);

  ///
  // Called after the renderer and JavaScript in the page has had a chance to
@@ -74,11 +77,11 @@ typedef struct _cef_keyboard_handler_t {
  // if the keyboard event was handled or false (0) otherwise.
  ///
  int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self,
-      struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
+                                  struct _cef_browser_t* browser,
+                                  const struct _cef_key_event_t* event,
                                  cef_event_handle_t os_event);
 } cef_keyboard_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_life_span_handler_capi.h
+++ b/include/capi/cef_life_span_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=fe38af40efe76e5d6babf0644d7d4af679a4ca6f$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@@ -56,10 +58,10 @@ typedef struct _cef_life_span_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
-  // Called on the IO thread before a new popup browser is created. The
+  // Called on the UI thread before a new popup browser is created. The
  // |browser| and |frame| values represent the source of the popup request. The
  // |target_url| and |target_frame_name| values indicate where the popup
  // browser should navigate and may be NULL if not specified with the request.
@@ -76,15 +78,23 @@ typedef struct _cef_life_span_handler_t {
  // is set to false (0) the new browser will not be scriptable and may not be
  // hosted in the same renderer process as the source browser. Any
  // modifications to |windowInfo| will be ignored if the parent browser is
-  // wrapped in a cef_browser_view_t.
+  // wrapped in a cef_browser_view_t. Popup browser creation will be canceled if
+  // the parent browser is destroyed before the popup browser creation completes
+  // (indicated by a call to OnAfterCreated for the popup browser).
  ///
-  int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      const cef_string_t* target_url, const cef_string_t* target_frame_name,
-      cef_window_open_disposition_t target_disposition, int user_gesture,
+  int(CEF_CALLBACK* on_before_popup)(
+      struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      const cef_string_t* target_url,
+      const cef_string_t* target_frame_name,
+      cef_window_open_disposition_t target_disposition,
+      int user_gesture,
      const struct _cef_popup_features_t* popupFeatures,
-      struct _cef_window_info_t* windowInfo, struct _cef_client_t** client,
-      struct _cef_browser_settings_t* settings, int* no_javascript_access);
+      struct _cef_window_info_t* windowInfo,
+      struct _cef_client_t** client,
+      struct _cef_browser_settings_t* settings,
+      int* no_javascript_access);

  ///
  // Called after a new browser is created. This callback will be the first
@@ -196,7 +206,6 @@ typedef struct _cef_life_span_handler_t {
                                      struct _cef_browser_t* browser);
 } cef_life_span_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_load_handler_capi.h
+++ b/include/capi/cef_load_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=d8fa87bb47ec889cab864fe96f94e07bf1deb0f6$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events related to browser load status. The
 // functions of this structure will be called on the browser process UI thread
@@ -56,7 +57,7 @@ typedef struct _cef_load_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when the loading state has changed. This callback will be executed
@@ -66,22 +67,26 @@ typedef struct _cef_load_handler_t {
  // calls to OnLoadError and/or OnLoadEnd.
  ///
  void(CEF_CALLBACK* on_loading_state_change)(struct _cef_load_handler_t* self,
-      struct _cef_browser_t* browser, int isLoading, int canGoBack,
+                                              struct _cef_browser_t* browser,
+                                              int isLoading,
+                                              int canGoBack,
                                              int canGoForward);

  ///
-  // Called when the browser begins loading a frame. The |frame| value will
-  // never be NULL -- call the is_main() function to check if this frame is the
-  // main frame. |transition_type| provides information about the source of the
-  // navigation and an accurate value is only available in the browser process.
-  // Multiple frames may be loading at the same time. Sub-frames may start or
-  // continue loading after the main frame load has ended. This function will
-  // always be called for all frames irrespective of whether the request
-  // completes successfully. For notification of overall browser load status use
-  // OnLoadingStateChange instead.
+  // Called after a navigation has been committed and before the browser begins
+  // loading contents in the frame. The |frame| value will never be NULL -- call
+  // the is_main() function to check if this frame is the main frame.
+  // |transition_type| provides information about the source of the navigation
+  // and an accurate value is only available in the browser process. Multiple
+  // frames may be loading at the same time. Sub-frames may start or continue
+  // loading after the main frame load has ended. This function will not be
+  // called for same page navigations (fragments, history state, etc.) or for
+  // navigations that fail or are canceled before commit. For notification of
+  // overall browser load status use OnLoadingStateChange instead.
  ///
  void(CEF_CALLBACK* on_load_start)(struct _cef_load_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+                                    struct _cef_browser_t* browser,
+                                    struct _cef_frame_t* frame,
                                    cef_transition_type_t transition_type);

  ///
@@ -89,27 +94,31 @@ typedef struct _cef_load_handler_t {
  // never be NULL -- call the is_main() function to check if this frame is the
  // main frame. Multiple frames may be loading at the same time. Sub-frames may
  // start or continue loading after the main frame load has ended. This
-  // function will always be called for all frames irrespective of whether the
-  // request completes successfully. For notification of overall browser load
-  // status use OnLoadingStateChange instead.
+  // function will not be called for same page navigations (fragments, history
+  // state, etc.) or for navigations that fail or are canceled before commit.
+  // For notification of overall browser load status use OnLoadingStateChange
+  // instead.
  ///
  void(CEF_CALLBACK* on_load_end)(struct _cef_load_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+                                  struct _cef_browser_t* browser,
+                                  struct _cef_frame_t* frame,
                                  int httpStatusCode);

  ///
-  // Called when the resource load for a navigation fails or is canceled.
-  // |errorCode| is the error code number, |errorText| is the error text and
-  // |failedUrl| is the URL that failed to load. See net\base\net_error_list.h
-  // for complete descriptions of the error codes.
+  // Called when a navigation fails or is canceled. This function may be called
+  // by itself if before commit or in combination with OnLoadStart/OnLoadEnd if
+  // after commit. |errorCode| is the error code number, |errorText| is the
+  // error text and |failedUrl| is the URL that failed to load. See
+  // net\base\net_error_list.h for complete descriptions of the error codes.
  ///
  void(CEF_CALLBACK* on_load_error)(struct _cef_load_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      cef_errorcode_t errorCode, const cef_string_t* errorText,
+                                    struct _cef_browser_t* browser,
+                                    struct _cef_frame_t* frame,
+                                    cef_errorcode_t errorCode,
+                                    const cef_string_t* errorText,
                                    const cef_string_t* failedUrl);
 } cef_load_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_menu_model_capi.h
+++ b/include/capi/cef_menu_model_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=295f7f55ebe6d548aba1476e67efb2c88ab10ca5$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Supports creation and modification of menus. See cef_menu_id_t for the
 // command ids that have default implementations. All user-defined command ids
@@ -56,7 +57,12 @@ typedef struct _cef_menu_model_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;
+
+  ///
+  // Returns true (1) if this menu is a submenu.
+  ///
+  int(CEF_CALLBACK* is_sub_menu)(struct _cef_menu_model_t* self);

  ///
  // Clears the menu. Returns true (1) on success.
@@ -76,27 +82,32 @@ typedef struct _cef_menu_model_t {
  ///
  // Add an item to the menu. Returns true (1) on success.
  ///
-  int (CEF_CALLBACK *add_item)(struct _cef_menu_model_t* self, int command_id,
+  int(CEF_CALLBACK* add_item)(struct _cef_menu_model_t* self,
+                              int command_id,
                              const cef_string_t* label);

  ///
  // Add a check item to the menu. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* add_check_item)(struct _cef_menu_model_t* self,
-      int command_id, const cef_string_t* label);
+                                    int command_id,
+                                    const cef_string_t* label);

  ///
  // Add a radio item to the menu. Only a single item with the specified
  // |group_id| can be checked at a time. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* add_radio_item)(struct _cef_menu_model_t* self,
-      int command_id, const cef_string_t* label, int group_id);
+                                    int command_id,
+                                    const cef_string_t* label,
+                                    int group_id);

  ///
  // Add a sub-menu to the menu. The new sub-menu is returned.
  ///
  struct _cef_menu_model_t*(CEF_CALLBACK* add_sub_menu)(
-      struct _cef_menu_model_t* self, int command_id,
+      struct _cef_menu_model_t* self,
+      int command_id,
      const cef_string_t* label);

  ///
@@ -110,15 +121,19 @@ typedef struct _cef_menu_model_t {
  // Insert an item in the menu at the specified |index|. Returns true (1) on
  // success.
  ///
-  int (CEF_CALLBACK *insert_item_at)(struct _cef_menu_model_t* self, int index,
-      int command_id, const cef_string_t* label);
+  int(CEF_CALLBACK* insert_item_at)(struct _cef_menu_model_t* self,
+                                    int index,
+                                    int command_id,
+                                    const cef_string_t* label);

  ///
  // Insert a check item in the menu at the specified |index|. Returns true (1)
  // on success.
  ///
  int(CEF_CALLBACK* insert_check_item_at)(struct _cef_menu_model_t* self,
-      int index, int command_id, const cef_string_t* label);
+                                          int index,
+                                          int command_id,
+                                          const cef_string_t* label);

  ///
  // Insert a radio item in the menu at the specified |index|. Only a single
@@ -126,14 +141,19 @@ typedef struct _cef_menu_model_t {
  // (1) on success.
  ///
  int(CEF_CALLBACK* insert_radio_item_at)(struct _cef_menu_model_t* self,
-      int index, int command_id, const cef_string_t* label, int group_id);
+                                          int index,
+                                          int command_id,
+                                          const cef_string_t* label,
+                                          int group_id);

  ///
  // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
  // returned.
  ///
  struct _cef_menu_model_t*(CEF_CALLBACK* insert_sub_menu_at)(
-      struct _cef_menu_model_t* self, int index, int command_id,
+      struct _cef_menu_model_t* self,
+      int index,
+      int command_id,
      const cef_string_t* label);

  ///
@@ -165,33 +185,36 @@ typedef struct _cef_menu_model_t {
  // Sets the command id at the specified |index|. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* set_command_id_at)(struct _cef_menu_model_t* self,
-      int index, int command_id);
+                                       int index,
+                                       int command_id);

  ///
  // Returns the label for the specified |command_id| or NULL if not found.
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t (CEF_CALLBACK *get_label)(
-      struct _cef_menu_model_t* self, int command_id);
+  cef_string_userfree_t(CEF_CALLBACK* get_label)(struct _cef_menu_model_t* self,
+                                                 int command_id);

  ///
  // Returns the label at the specified |index| or NULL if not found due to
  // invalid range or the index being a separator.
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
-  cef_string_userfree_t (CEF_CALLBACK *get_label_at)(
-      struct _cef_menu_model_t* self, int index);
+  cef_string_userfree_t(
+      CEF_CALLBACK* get_label_at)(struct _cef_menu_model_t* self, int index);

  ///
  // Sets the label for the specified |command_id|. Returns true (1) on success.
  ///
-  int (CEF_CALLBACK *set_label)(struct _cef_menu_model_t* self, int command_id,
+  int(CEF_CALLBACK* set_label)(struct _cef_menu_model_t* self,
+                               int command_id,
                               const cef_string_t* label);

  ///
  // Set the label at the specified |index|. Returns true (1) on success.
  ///
-  int (CEF_CALLBACK *set_label_at)(struct _cef_menu_model_t* self, int index,
+  int(CEF_CALLBACK* set_label_at)(struct _cef_menu_model_t* self,
+                                  int index,
                                  const cef_string_t* label);

  ///
@@ -203,8 +226,8 @@ typedef struct _cef_menu_model_t {
  ///
  // Returns the item type at the specified |index|.
  ///
-  cef_menu_item_type_t (CEF_CALLBACK *get_type_at)(
-      struct _cef_menu_model_t* self, int index);
+  cef_menu_item_type_t(
+      CEF_CALLBACK* get_type_at)(struct _cef_menu_model_t* self, int index);

  ///
  // Returns the group id for the specified |command_id| or -1 if invalid.
@@ -215,39 +238,40 @@ typedef struct _cef_menu_model_t {
  ///
  // Returns the group id at the specified |index| or -1 if invalid.
  ///
-  int (CEF_CALLBACK *get_group_id_at)(struct _cef_menu_model_t* self,
-      int index);
+  int(CEF_CALLBACK* get_group_id_at)(struct _cef_menu_model_t* self, int index);

  ///
  // Sets the group id for the specified |command_id|. Returns true (1) on
  // success.
  ///
  int(CEF_CALLBACK* set_group_id)(struct _cef_menu_model_t* self,
-      int command_id, int group_id);
+                                  int command_id,
+                                  int group_id);

  ///
  // Sets the group id at the specified |index|. Returns true (1) on success.
  ///
-  int (CEF_CALLBACK *set_group_id_at)(struct _cef_menu_model_t* self, int index,
+  int(CEF_CALLBACK* set_group_id_at)(struct _cef_menu_model_t* self,
+                                     int index,
                                     int group_id);

  ///
  // Returns the submenu for the specified |command_id| or NULL if invalid.
  ///
  struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu)(
-      struct _cef_menu_model_t* self, int command_id);
+      struct _cef_menu_model_t* self,
+      int command_id);

  ///
  // Returns the submenu at the specified |index| or NULL if invalid.
  ///
-  struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu_at)(
-      struct _cef_menu_model_t* self, int index);
+  struct _cef_menu_model_t*(
+      CEF_CALLBACK* get_sub_menu_at)(struct _cef_menu_model_t* self, int index);

  ///
  // Returns true (1) if the specified |command_id| is visible.
  ///
-  int (CEF_CALLBACK *is_visible)(struct _cef_menu_model_t* self,
-      int command_id);
+  int(CEF_CALLBACK* is_visible)(struct _cef_menu_model_t* self, int command_id);

  ///
  // Returns true (1) if the specified |index| is visible.
@@ -259,20 +283,21 @@ typedef struct _cef_menu_model_t {
  // success.
  ///
  int(CEF_CALLBACK* set_visible)(struct _cef_menu_model_t* self,
-      int command_id, int visible);
+                                 int command_id,
+                                 int visible);

  ///
  // Change the visibility at the specified |index|. Returns true (1) on
  // success.
  ///
-  int (CEF_CALLBACK *set_visible_at)(struct _cef_menu_model_t* self, int index,
+  int(CEF_CALLBACK* set_visible_at)(struct _cef_menu_model_t* self,
+                                    int index,
                                    int visible);

  ///
  // Returns true (1) if the specified |command_id| is enabled.
  ///
-  int (CEF_CALLBACK *is_enabled)(struct _cef_menu_model_t* self,
-      int command_id);
+  int(CEF_CALLBACK* is_enabled)(struct _cef_menu_model_t* self, int command_id);

  ///
  // Returns true (1) if the specified |index| is enabled.
@@ -284,21 +309,22 @@ typedef struct _cef_menu_model_t {
  // on success.
  ///
  int(CEF_CALLBACK* set_enabled)(struct _cef_menu_model_t* self,
-      int command_id, int enabled);
+                                 int command_id,
+                                 int enabled);

  ///
  // Change the enabled status at the specified |index|. Returns true (1) on
  // success.
  ///
-  int (CEF_CALLBACK *set_enabled_at)(struct _cef_menu_model_t* self, int index,
+  int(CEF_CALLBACK* set_enabled_at)(struct _cef_menu_model_t* self,
+                                    int index,
                                    int enabled);

  ///
  // Returns true (1) if the specified |command_id| is checked. Only applies to
  // check and radio items.
  ///
-  int (CEF_CALLBACK *is_checked)(struct _cef_menu_model_t* self,
-      int command_id);
+  int(CEF_CALLBACK* is_checked)(struct _cef_menu_model_t* self, int command_id);

  ///
  // Returns true (1) if the specified |index| is checked. Only applies to check
@@ -311,13 +337,15 @@ typedef struct _cef_menu_model_t {
  // Returns true (1) on success.
  ///
  int(CEF_CALLBACK* set_checked)(struct _cef_menu_model_t* self,
-      int command_id, int checked);
+                                 int command_id,
+                                 int checked);

  ///
  // Check the specified |index|. Only applies to check and radio items. Returns
  // true (1) on success.
  ///
-  int (CEF_CALLBACK *set_checked_at)(struct _cef_menu_model_t* self, int index,
+  int(CEF_CALLBACK* set_checked_at)(struct _cef_menu_model_t* self,
+                                    int index,
                                    int checked);

  ///
@@ -339,7 +367,10 @@ typedef struct _cef_menu_model_t {
  // be any virtual key or character value. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* set_accelerator)(struct _cef_menu_model_t* self,
-      int command_id, int key_code, int shift_pressed, int ctrl_pressed,
+                                     int command_id,
+                                     int key_code,
+                                     int shift_pressed,
+                                     int ctrl_pressed,
                                     int alt_pressed);

  ///
@@ -347,7 +378,10 @@ typedef struct _cef_menu_model_t {
  // any virtual key or character value. Returns true (1) on success.
  ///
  int(CEF_CALLBACK* set_accelerator_at)(struct _cef_menu_model_t* self,
-      int index, int key_code, int shift_pressed, int ctrl_pressed,
+                                        int index,
+                                        int key_code,
+                                        int shift_pressed,
+                                        int ctrl_pressed,
                                        int alt_pressed);

  ///
@@ -369,7 +403,10 @@ typedef struct _cef_menu_model_t {
  // true (1) on success.
  ///
  int(CEF_CALLBACK* get_accelerator)(struct _cef_menu_model_t* self,
-      int command_id, int* key_code, int* shift_pressed, int* ctrl_pressed,
+                                     int command_id,
+                                     int* key_code,
+                                     int* shift_pressed,
+                                     int* ctrl_pressed,
                                     int* alt_pressed);

  ///
@@ -377,10 +414,89 @@ typedef struct _cef_menu_model_t {
  // (1) on success.
  ///
  int(CEF_CALLBACK* get_accelerator_at)(struct _cef_menu_model_t* self,
-      int index, int* key_code, int* shift_pressed, int* ctrl_pressed,
+                                        int index,
+                                        int* key_code,
+                                        int* shift_pressed,
+                                        int* ctrl_pressed,
                                        int* alt_pressed);
-} cef_menu_model_t;

+  ///
+  // Set the explicit color for |command_id| and |color_type| to |color|.
+  // Specify a |color| value of 0 to remove the explicit color. If no explicit
+  // color or default color is set for |color_type| then the system color will
+  // be used. Returns true (1) on success.
+  ///
+  int(CEF_CALLBACK* set_color)(struct _cef_menu_model_t* self,
+                               int command_id,
+                               cef_menu_color_type_t color_type,
+                               cef_color_t color);
+
+  ///
+  // Set the explicit color for |command_id| and |index| to |color|. Specify a
+  // |color| value of 0 to remove the explicit color. Specify an |index| value
+  // of -1 to set the default color for items that do not have an explicit color
+  // set. If no explicit color or default color is set for |color_type| then the
+  // system color will be used. Returns true (1) on success.
+  ///
+  int(CEF_CALLBACK* set_color_at)(struct _cef_menu_model_t* self,
+                                  int index,
+                                  cef_menu_color_type_t color_type,
+                                  cef_color_t color);
+
+  ///
+  // Returns in |color| the color that was explicitly set for |command_id| and
+  // |color_type|. If a color was not set then 0 will be returned in |color|.
+  // Returns true (1) on success.
+  ///
+  int(CEF_CALLBACK* get_color)(struct _cef_menu_model_t* self,
+                               int command_id,
+                               cef_menu_color_type_t color_type,
+                               cef_color_t* color);
+
+  ///
+  // Returns in |color| the color that was explicitly set for |command_id| and
+  // |color_type|. Specify an |index| value of -1 to return the default color in
+  // |color|. If a color was not set then 0 will be returned in |color|. Returns
+  // true (1) on success.
+  ///
+  int(CEF_CALLBACK* get_color_at)(struct _cef_menu_model_t* self,
+                                  int index,
+                                  cef_menu_color_type_t color_type,
+                                  cef_color_t* color);
+
+  ///
+  // Sets the font list for the specified |command_id|. If |font_list| is NULL
+  // the system font will be used. Returns true (1) on success. The format is
+  // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
+  // separated list of font family names, - STYLES is an optional space-
+  // separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings: - "Arial, Helvetica,
+  // Bold Italic 14px" - "Arial, 14px"
+  ///
+  int(CEF_CALLBACK* set_font_list)(struct _cef_menu_model_t* self,
+                                   int command_id,
+                                   const cef_string_t* font_list);
+
+  ///
+  // Sets the font list for the specified |index|. Specify an |index| value of
+  // -1 to set the default font. If |font_list| is NULL the system font will be
+  // used. Returns true (1) on success. The format is
+  // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
+  // separated list of font family names, - STYLES is an optional space-
+  // separated list of style names (case-sensitive
+  //   "Bold" and "Italic" are supported), and
+  // - SIZE is an integer font size in pixels with the suffix "px".
+  //
+  // Here are examples of valid font description strings: - "Arial, Helvetica,
+  // Bold Italic 14px" - "Arial, 14px"
+  ///
+  int(CEF_CALLBACK* set_font_list_at)(struct _cef_menu_model_t* self,
+                                      int index,
+                                      const cef_string_t* font_list);
+} cef_menu_model_t;

 ///
 // Create a new MenuModel with the specified |delegate|.
@@ -388,7 +504,6 @@ typedef struct _cef_menu_model_t {
 CEF_EXPORT cef_menu_model_t* cef_menu_model_create(
    struct _cef_menu_model_delegate_t* delegate);

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_menu_model_delegate_capi.h
+++ b/include/capi/cef_menu_model_delegate_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=74f40f20f94ce3a6e7f3c879a3834a7108099ed4$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
@@ -55,16 +57,44 @@ typedef struct _cef_menu_model_delegate_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Perform the action associated with the specified |command_id| and optional
  // |event_flags|.
  ///
  void(CEF_CALLBACK* execute_command)(struct _cef_menu_model_delegate_t* self,
-      struct _cef_menu_model_t* menu_model, int command_id,
+                                      struct _cef_menu_model_t* menu_model,
+                                      int command_id,
                                      cef_event_flags_t event_flags);

+  ///
+  // Called when the user moves the mouse outside the menu and over the owning
+  // window.
+  ///
+  void(CEF_CALLBACK* mouse_outside_menu)(
+      struct _cef_menu_model_delegate_t* self,
+      struct _cef_menu_model_t* menu_model,
+      const cef_point_t* screen_point);
+
+  ///
+  // Called on unhandled open submenu keyboard commands. |is_rtl| will be true
+  // (1) if the menu is displaying a right-to-left language.
+  ///
+  void(CEF_CALLBACK* unhandled_open_submenu)(
+      struct _cef_menu_model_delegate_t* self,
+      struct _cef_menu_model_t* menu_model,
+      int is_rtl);
+
+  ///
+  // Called on unhandled close submenu keyboard commands. |is_rtl| will be true
+  // (1) if the menu is displaying a right-to-left language.
+  ///
+  void(CEF_CALLBACK* unhandled_close_submenu)(
+      struct _cef_menu_model_delegate_t* self,
+      struct _cef_menu_model_t* menu_model,
+      int is_rtl);
+
  ///
  // The menu is about to show.
  ///
@@ -82,10 +112,10 @@ typedef struct _cef_menu_model_delegate_t {
  // modified.
  ///
  int(CEF_CALLBACK* format_label)(struct _cef_menu_model_delegate_t* self,
-      struct _cef_menu_model_t* menu_model, cef_string_t* label);
+                                  struct _cef_menu_model_t* menu_model,
+                                  cef_string_t* label);
 } cef_menu_model_delegate_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_navigation_entry_capi.h
+++ b/include/capi/cef_navigation_entry_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=a862d0004de2a1bdf4c214fe87278badd90562a7$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to represent an entry in navigation history.
 ///
@@ -53,7 +54,7 @@ typedef struct _cef_navigation_entry_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is valid. Do not call any other functions
@@ -115,8 +116,7 @@ typedef struct _cef_navigation_entry_t {
  // response. May be 0 if the response has not yet been received or if the
  // navigation has not yet completed.
  ///
-  int (CEF_CALLBACK *get_http_status_code)(
-      struct _cef_navigation_entry_t* self);
+  int(CEF_CALLBACK* get_http_status_code)(struct _cef_navigation_entry_t* self);

  ///
  // Returns the SSL information for this navigation entry.
@@ -125,7 +125,6 @@ typedef struct _cef_navigation_entry_t {
      struct _cef_navigation_entry_t* self);
 } cef_navigation_entry_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_origin_whitelist_capi.h
+++ b/include/capi/cef_origin_whitelist_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=2e5afff3277384ea9f3f74ef509c018f6d307dc4$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Add an entry to the cross-origin access whitelist.
 //
@@ -82,16 +83,20 @@ extern "C" {
 // |source_origin| is invalid or the whitelist cannot be accessed.
 ///
 CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
-    const cef_string_t* source_origin, const cef_string_t* target_protocol,
-    const cef_string_t* target_domain, int allow_target_subdomains);
+    const cef_string_t* source_origin,
+    const cef_string_t* target_protocol,
+    const cef_string_t* target_domain,
+    int allow_target_subdomains);

 ///
 // Remove an entry from the cross-origin access whitelist. Returns false (0) if
 // |source_origin| is invalid or the whitelist cannot be accessed.
 ///
 CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
-    const cef_string_t* source_origin, const cef_string_t* target_protocol,
-    const cef_string_t* target_domain, int allow_target_subdomains);
+    const cef_string_t* source_origin,
+    const cef_string_t* target_protocol,
+    const cef_string_t* target_domain,
+    int allow_target_subdomains);

 ///
 // Remove all entries from the cross-origin access whitelist. Returns false (0)
--- a/include/capi/cef_parser_capi.h
+++ b/include/capi/cef_parser_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=d2f01fbfc3ae72a86c03399606088054b3a9337f$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Parse the specified |url| into its component parts. Returns false (0) if the
 // URL is NULL or invalid.
@@ -71,16 +72,16 @@ CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts,
 // for URLs which will be parsed or sent to other applications.
 ///
 // The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_format_url_for_security_display(
-    const cef_string_t* origin_url);
+CEF_EXPORT cef_string_userfree_t
+cef_format_url_for_security_display(const cef_string_t* origin_url);

 ///
 // Returns the mime type for the specified file extension or an NULL string if
 // unknown.
 ///
 // The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_get_mime_type(
-    const cef_string_t* extension);
+CEF_EXPORT cef_string_userfree_t
+cef_get_mime_type(const cef_string_t* extension);

 ///
 // Get the extensions associated with the given mime type. This should be passed
@@ -126,14 +127,17 @@ CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text,
 // supports further customization the decoding process.
 ///
 // The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text,
-    int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule);
+CEF_EXPORT cef_string_userfree_t
+cef_uridecode(const cef_string_t* text,
+              int convert_to_utf8,
+              cef_uri_unescape_rule_t unescape_rule);

 ///
 // Parses the specified |json_string| and returns a dictionary or list
 // representation. If JSON parsing fails this function returns NULL.
 ///
-CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
+CEF_EXPORT struct _cef_value_t* cef_parse_json(
+    const cef_string_t* json_string,
    cef_json_parser_options_t options);

 ///
@@ -143,8 +147,10 @@ CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
 // formatted error message respectively.
 ///
 CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
-    const cef_string_t* json_string, cef_json_parser_options_t options,
-    cef_json_parser_error_t* error_code_out, cef_string_t* error_msg_out);
+    const cef_string_t* json_string,
+    cef_json_parser_options_t options,
+    cef_json_parser_error_t* error_code_out,
+    cef_string_t* error_msg_out);

 ///
 // Generates a JSON string from the specified root |node| which should be a
@@ -152,8 +158,8 @@ CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
 // requires exclusive access to |node| including any underlying data.
 ///
 // The resulting string must be freed by calling cef_string_userfree_free().
-CEF_EXPORT cef_string_userfree_t cef_write_json(struct _cef_value_t* node,
-    cef_json_writer_options_t options);
+CEF_EXPORT cef_string_userfree_t
+cef_write_json(struct _cef_value_t* node, cef_json_writer_options_t options);

 #ifdef __cplusplus
 }
--- a/include/capi/cef_path_util_capi.h
+++ b/include/capi/cef_path_util_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=fbb817705137a12b4718950ff696396c30057007$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Retrieve the path associated with the specified |key|. Returns true (1) on
 // success. Can be called on any thread in the browser process.
--- a/include/capi/cef_print_handler_capi.h
+++ b/include/capi/cef_print_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=897f5b1ec6ed7430fff156f47b4ce6371d5db6f2$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure for asynchronous continuation of print dialog requests.
 ///
@@ -54,7 +55,7 @@ typedef struct _cef_print_dialog_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue printing with the specified |settings|.
@@ -68,7 +69,6 @@ typedef struct _cef_print_dialog_callback_t {
  void(CEF_CALLBACK* cancel)(struct _cef_print_dialog_callback_t* self);
 } cef_print_dialog_callback_t;

-
 ///
 // Callback structure for asynchronous continuation of print job requests.
 ///
@@ -76,7 +76,7 @@ typedef struct _cef_print_job_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Indicate completion of the print job.
@@ -84,16 +84,16 @@ typedef struct _cef_print_job_callback_t {
  void(CEF_CALLBACK* cont)(struct _cef_print_job_callback_t* self);
 } cef_print_job_callback_t;

-
 ///
-// Implement this structure to handle printing on Linux. The functions of this
-// structure will be called on the browser process UI thread.
+// Implement this structure to handle printing on Linux. Each browser will have
+// only one print job in progress at a time. The functions of this structure
+// will be called on the browser process UI thread.
 ///
 typedef struct _cef_print_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called when printing has started for the specified |browser|. This function
@@ -110,15 +110,20 @@ typedef struct _cef_print_handler_t {
  // reference to |settings| outside of this callback.
  ///
  void(CEF_CALLBACK* on_print_settings)(struct _cef_print_handler_t* self,
-      struct _cef_print_settings_t* settings, int get_defaults);
+                                        struct _cef_browser_t* browser,
+                                        struct _cef_print_settings_t* settings,
+                                        int get_defaults);

  ///
  // Show the print dialog. Execute |callback| once the dialog is dismissed.
  // Return true (1) if the dialog will be displayed or false (0) to cancel the
  // printing immediately.
  ///
-  int (CEF_CALLBACK *on_print_dialog)(struct _cef_print_handler_t* self,
-      int has_selection, struct _cef_print_dialog_callback_t* callback);
+  int(CEF_CALLBACK* on_print_dialog)(
+      struct _cef_print_handler_t* self,
+      struct _cef_browser_t* browser,
+      int has_selection,
+      struct _cef_print_dialog_callback_t* callback);

  ///
  // Send the print job to the printer. Execute |callback| once the job is
@@ -126,23 +131,26 @@ typedef struct _cef_print_handler_t {
  // the job immediately.
  ///
  int(CEF_CALLBACK* on_print_job)(struct _cef_print_handler_t* self,
-      const cef_string_t* document_name, const cef_string_t* pdf_file_path,
+                                  struct _cef_browser_t* browser,
+                                  const cef_string_t* document_name,
+                                  const cef_string_t* pdf_file_path,
                                  struct _cef_print_job_callback_t* callback);

  ///
  // Reset client state related to printing.
  ///
-  void (CEF_CALLBACK *on_print_reset)(struct _cef_print_handler_t* self);
+  void(CEF_CALLBACK* on_print_reset)(struct _cef_print_handler_t* self,
+                                     struct _cef_browser_t* browser);

  ///
  // Return the PDF paper size in device units. Used in combination with
  // cef_browser_host_t::print_to_pdf().
  ///
  cef_size_t(CEF_CALLBACK* get_pdf_paper_size)(
-      struct _cef_print_handler_t* self, int device_units_per_inch);
+      struct _cef_print_handler_t* self,
+      int device_units_per_inch);
 } cef_print_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_print_settings_capi.h
+++ b/include/capi/cef_print_settings_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=5b26ebd2d8e1e65a25fa0c08317b8994887c0498$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure representing print settings.
 ///
@@ -52,7 +53,7 @@ typedef struct _cef_print_settings_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is valid. Do not call any other functions
@@ -121,7 +122,8 @@ typedef struct _cef_print_settings_t {
  // Set the page ranges.
  ///
  void(CEF_CALLBACK* set_page_ranges)(struct _cef_print_settings_t* self,
-      size_t rangesCount, cef_range_t const* ranges);
+                                      size_t rangesCount,
+                                      cef_range_t const* ranges);

  ///
  // Returns the number of page ranges that currently exist.
@@ -133,7 +135,8 @@ typedef struct _cef_print_settings_t {
  // Retrieve the page ranges.
  ///
  void(CEF_CALLBACK* get_page_ranges)(struct _cef_print_settings_t* self,
-      size_t* rangesCount, cef_range_t* ranges);
+                                      size_t* rangesCount,
+                                      cef_range_t* ranges);

  ///
  // Set whether only the selection will be printed.
@@ -193,13 +196,11 @@ typedef struct _cef_print_settings_t {
      struct _cef_print_settings_t* self);
 } cef_print_settings_t;

-
 ///
 // Create a new cef_print_settings_t object.
 ///
 CEF_EXPORT cef_print_settings_t* cef_print_settings_create();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_process_message_capi.h
+++ b/include/capi/cef_process_message_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=c2ee22474637f9aed7673670fb10c960ae621535$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure representing a message. Can be used on any process and thread.
 ///
@@ -53,7 +54,7 @@ typedef struct _cef_process_message_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is valid. Do not call any other functions
@@ -87,14 +88,12 @@ typedef struct _cef_process_message_t {
      struct _cef_process_message_t* self);
 } cef_process_message_t;

-
 ///
 // Create a new cef_process_message_t object with the specified name.
 ///
 CEF_EXPORT cef_process_message_t* cef_process_message_create(
    const cef_string_t* name);

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_process_util_capi.h
+++ b/include/capi/cef_process_util_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=aad07da2d500b8d31e02a75331bdb68f16d4c662$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Launches the process specified via |command_line|. Returns true (1) upon
 // success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
--- a/include/capi/cef_render_handler_capi.h
+++ b/include/capi/cef_render_handler_capi.h
@@ -33,11 +33,14 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=5d20fc88dea8dad8691f05bfb7e8c1ce5cf2bbc1$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
 #pragma once

+#include "include/capi/cef_accessibility_handler_capi.h"
 #include "include/capi/cef_base_capi.h"
 #include "include/capi/cef_browser_capi.h"
 #include "include/capi/cef_drag_data_capi.h"
@@ -46,7 +49,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to handle events when window rendering is disabled.
 // The functions of this structure will be called on the UI thread.
@@ -55,28 +57,40 @@ typedef struct _cef_render_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;
+
+  ///
+  // Return the handler for accessibility notifications. If no handler is
+  // provided the default implementation will be used.
+  ///
+  struct _cef_accessibility_handler_t*(CEF_CALLBACK* get_accessibility_handler)(
+      struct _cef_render_handler_t* self);

  ///
  // Called to retrieve the root window rectangle in screen coordinates. Return
  // true (1) if the rectangle was provided.
  ///
  int(CEF_CALLBACK* get_root_screen_rect)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, cef_rect_t* rect);
+                                          struct _cef_browser_t* browser,
+                                          cef_rect_t* rect);

  ///
  // Called to retrieve the view rectangle which is relative to screen
  // coordinates. Return true (1) if the rectangle was provided.
  ///
  int(CEF_CALLBACK* get_view_rect)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, cef_rect_t* rect);
+                                   struct _cef_browser_t* browser,
+                                   cef_rect_t* rect);

  ///
  // Called to retrieve the translation from view coordinates to actual screen
  // coordinates. Return true (1) if the screen coordinates were provided.
  ///
  int(CEF_CALLBACK* get_screen_point)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, int viewX, int viewY, int* screenX,
+                                      struct _cef_browser_t* browser,
+                                      int viewX,
+                                      int viewY,
+                                      int* screenX,
                                      int* screenY);

  ///
@@ -89,21 +103,24 @@ typedef struct _cef_render_handler_t {
  // drawn correctly.
  ///
  int(CEF_CALLBACK* get_screen_info)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_screen_info_t* screen_info);
+                                     struct _cef_browser_t* browser,
+                                     struct _cef_screen_info_t* screen_info);

  ///
  // Called when the browser wants to show or hide the popup widget. The popup
  // should be shown if |show| is true (1) and hidden if |show| is false (0).
  ///
  void(CEF_CALLBACK* on_popup_show)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, int show);
+                                    struct _cef_browser_t* browser,
+                                    int show);

  ///
  // Called when the browser wants to move or resize the popup widget. |rect|
  // contains the new location and size in view coordinates.
  ///
  void(CEF_CALLBACK* on_popup_size)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, const cef_rect_t* rect);
+                                    struct _cef_browser_t* browser,
+                                    const cef_rect_t* rect);

  ///
  // Called when an element should be painted. Pixel values passed to this
@@ -116,16 +133,22 @@ typedef struct _cef_render_handler_t {
  // upper-left origin.
  ///
  void(CEF_CALLBACK* on_paint)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, cef_paint_element_type_t type,
-      size_t dirtyRectsCount, cef_rect_t const* dirtyRects, const void* buffer,
-      int width, int height);
+                               struct _cef_browser_t* browser,
+                               cef_paint_element_type_t type,
+                               size_t dirtyRectsCount,
+                               cef_rect_t const* dirtyRects,
+                               const void* buffer,
+                               int width,
+                               int height);

  ///
  // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
  // |custom_cursor_info| will be populated with the custom cursor information.
  ///
-  void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, cef_cursor_handle_t cursor,
+  void(CEF_CALLBACK* on_cursor_change)(
+      struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser,
+      cef_cursor_handle_t cursor,
      cef_cursor_type_t type,
      const struct _cef_cursor_info_t* custom_cursor_info);

@@ -144,8 +167,11 @@ typedef struct _cef_render_handler_t {
  // operation has ended.
  ///
  int(CEF_CALLBACK* start_dragging)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_drag_data_t* drag_data,
-      cef_drag_operations_mask_t allowed_ops, int x, int y);
+                                    struct _cef_browser_t* browser,
+                                    struct _cef_drag_data_t* drag_data,
+                                    cef_drag_operations_mask_t allowed_ops,
+                                    int x,
+                                    int y);

  ///
  // Called when the web view wants to update the mouse cursor during a drag &
@@ -153,14 +179,17 @@ typedef struct _cef_render_handler_t {
  // copy, link).
  ///
  void(CEF_CALLBACK* update_drag_cursor)(struct _cef_render_handler_t* self,
-      struct _cef_browser_t* browser, cef_drag_operations_mask_t operation);
+                                         struct _cef_browser_t* browser,
+                                         cef_drag_operations_mask_t operation);

  ///
  // Called when the scroll offset has changed.
  ///
  void(CEF_CALLBACK* on_scroll_offset_changed)(
-      struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
-      double x, double y);
+      struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser,
+      double x,
+      double y);

  ///
  // Called when the IME composition range has changed. |selected_range| is the
@@ -168,12 +197,13 @@ typedef struct _cef_render_handler_t {
  // bounds of each character in view coordinates.
  ///
  void(CEF_CALLBACK* on_ime_composition_range_changed)(
-      struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
-      const cef_range_t* selected_range, size_t character_boundsCount,
+      struct _cef_render_handler_t* self,
+      struct _cef_browser_t* browser,
+      const cef_range_t* selected_range,
+      size_t character_boundsCount,
      cef_rect_t const* character_bounds);
 } cef_render_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_render_process_handler_capi.h
+++ b/include/capi/cef_render_process_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=04ddf8c8cc5e09610a6cd6dbee96194eb6567b41$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
@@ -51,7 +53,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to implement render process callbacks. The functions of this
 // structure will be called on the render process main thread (TID_RENDERER)
@@ -61,7 +62,7 @@ typedef struct _cef_render_process_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called after the render process main thread has been created. |extra_info|
@@ -108,8 +109,10 @@ typedef struct _cef_render_process_handler_t {
  ///
  int(CEF_CALLBACK* on_before_navigation)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      struct _cef_request_t* request, cef_navigation_type_t navigation_type,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_request_t* request,
+      cef_navigation_type_t navigation_type,
      int is_redirect);

  ///
@@ -122,7 +125,8 @@ typedef struct _cef_render_process_handler_t {
  ///
  void(CEF_CALLBACK* on_context_created)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
      struct _cef_v8context_t* context);

  ///
@@ -131,7 +135,8 @@ typedef struct _cef_render_process_handler_t {
  ///
  void(CEF_CALLBACK* on_context_released)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
      struct _cef_v8context_t* context);

  ///
@@ -141,8 +146,10 @@ typedef struct _cef_render_process_handler_t {
  ///
  void(CEF_CALLBACK* on_uncaught_exception)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      struct _cef_v8context_t* context, struct _cef_v8exception_t* exception,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_v8context_t* context,
+      struct _cef_v8exception_t* exception,
      struct _cef_v8stack_trace_t* stackTrace);

  ///
@@ -155,7 +162,8 @@ typedef struct _cef_render_process_handler_t {
  ///
  void(CEF_CALLBACK* on_focused_node_changed)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
      struct _cef_domnode_t* node);

  ///
@@ -165,11 +173,11 @@ typedef struct _cef_render_process_handler_t {
  ///
  int(CEF_CALLBACK* on_process_message_received)(
      struct _cef_render_process_handler_t* self,
-      struct _cef_browser_t* browser, cef_process_id_t source_process,
+      struct _cef_browser_t* browser,
+      cef_process_id_t source_process,
      struct _cef_process_message_t* message);
 } cef_render_process_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_request_capi.h
+++ b/include/capi/cef_request_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=e4d28f171862beea61f00e46d7acb8ee4154b077$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
@@ -55,7 +57,7 @@ typedef struct _cef_request_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is read-only.
@@ -93,7 +95,8 @@ typedef struct _cef_request_t {
  // ref component will be removed.
  ///
  void(CEF_CALLBACK* set_referrer)(struct _cef_request_t* self,
-      const cef_string_t* referrer_url, cef_referrer_policy_t policy);
+                                   const cef_string_t* referrer_url,
+                                   cef_referrer_policy_t policy);

  ///
  // Get the referrer URL.
@@ -136,8 +139,10 @@ typedef struct _cef_request_t {
  ///
  // Set all values at one time.
  ///
-  void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url,
-      const cef_string_t* method, struct _cef_post_data_t* postData,
+  void(CEF_CALLBACK* set)(struct _cef_request_t* self,
+                          const cef_string_t* url,
+                          const cef_string_t* method,
+                          struct _cef_post_data_t* postData,
                          cef_string_multimap_t headerMap);

  ///
@@ -190,13 +195,11 @@ typedef struct _cef_request_t {
  uint64(CEF_CALLBACK* get_identifier)(struct _cef_request_t* self);
 } cef_request_t;

-
 ///
 // Create a new cef_request_t object.
 ///
 CEF_EXPORT cef_request_t* cef_request_create();

-
 ///
 // Structure used to represent post data for a web request. The functions of
 // this structure may be called on any thread.
@@ -205,7 +208,7 @@ typedef struct _cef_post_data_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is read-only.
@@ -229,7 +232,8 @@ typedef struct _cef_post_data_t {
  // Retrieve the post data elements.
  ///
  void(CEF_CALLBACK* get_elements)(struct _cef_post_data_t* self,
-      size_t* elementsCount, struct _cef_post_data_element_t** elements);
+                                   size_t* elementsCount,
+                                   struct _cef_post_data_element_t** elements);

  ///
  // Remove the specified post data element.  Returns true (1) if the removal
@@ -250,13 +254,11 @@ typedef struct _cef_post_data_t {
  void(CEF_CALLBACK* remove_elements)(struct _cef_post_data_t* self);
 } cef_post_data_t;

-
 ///
 // Create a new cef_post_data_t object.
 ///
 CEF_EXPORT cef_post_data_t* cef_post_data_create();

-
 ///
 // Structure used to represent a single element in the request post data. The
 // functions of this structure may be called on any thread.
@@ -265,7 +267,7 @@ typedef struct _cef_post_data_element_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is read-only.
@@ -288,7 +290,8 @@ typedef struct _cef_post_data_element_t {
  // copied.
  ///
  void(CEF_CALLBACK* set_to_bytes)(struct _cef_post_data_element_t* self,
-      size_t size, const void* bytes);
+                                   size_t size,
+                                   const void* bytes);

  ///
  // Return the type of this post data element.
@@ -313,16 +316,15 @@ typedef struct _cef_post_data_element_t {
  // actually read.
  ///
  size_t(CEF_CALLBACK* get_bytes)(struct _cef_post_data_element_t* self,
-      size_t size, void* bytes);
+                                  size_t size,
+                                  void* bytes);
 } cef_post_data_element_t;

-
 ///
 // Create a new cef_post_data_element_t object.
 ///
 CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_request_context_capi.h
+++ b/include/capi/cef_request_context_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=791231acc78a2b601257fb0b86d904eace796d63$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
@@ -56,19 +58,18 @@ typedef struct _cef_resolve_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called after the ResolveHost request has completed. |result| will be the
  // result code. |resolved_ips| will be the list of resolved IP addresses or
  // NULL if the resolution failed.
  ///
-  void (CEF_CALLBACK *on_resolve_completed)(
-      struct _cef_resolve_callback_t* self, cef_errorcode_t result,
+  void(CEF_CALLBACK* on_resolve_completed)(struct _cef_resolve_callback_t* self,
+                                           cef_errorcode_t result,
                                           cef_string_list_t resolved_ips);
 } cef_resolve_callback_t;

-
 ///
 // A request context provides request handling for a set of related browser or
 // URL request objects. A request context can be specified when creating a new
@@ -89,7 +90,7 @@ typedef struct _cef_request_context_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is pointing to the same context as |that|
@@ -152,7 +153,8 @@ typedef struct _cef_request_context_t {
  // may be called on any thread in the browser process.
  ///
  int(CEF_CALLBACK* register_scheme_handler_factory)(
-      struct _cef_request_context_t* self, const cef_string_t* scheme_name,
+      struct _cef_request_context_t* self,
+      const cef_string_t* scheme_name,
      const cef_string_t* domain_name,
      struct _cef_scheme_handler_factory_t* factory);

@@ -171,7 +173,8 @@ typedef struct _cef_request_context_t {
  // the plugin list cache.
  ///
  void(CEF_CALLBACK* purge_plugin_list_cache)(
-      struct _cef_request_context_t* self, int reload_pages);
+      struct _cef_request_context_t* self,
+      int reload_pages);

  ///
  // Returns true (1) if a preference with the specified |name| exists. This
@@ -188,7 +191,8 @@ typedef struct _cef_request_context_t {
  // called on the browser process UI thread.
  ///
  struct _cef_value_t*(CEF_CALLBACK* get_preference)(
-      struct _cef_request_context_t* self, const cef_string_t* name);
+      struct _cef_request_context_t* self,
+      const cef_string_t* name);

  ///
  // Returns all preferences as a dictionary. If |include_defaults| is true (1)
@@ -199,7 +203,8 @@ typedef struct _cef_request_context_t {
  // thread.
  ///
  struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)(
-      struct _cef_request_context_t* self, int include_defaults);
+      struct _cef_request_context_t* self,
+      int include_defaults);

  ///
  // Returns true (1) if the preference with the specified |name| can be
@@ -218,7 +223,8 @@ typedef struct _cef_request_context_t {
  // problem. This function must be called on the browser process UI thread.
  ///
  int(CEF_CALLBACK* set_preference)(struct _cef_request_context_t* self,
-      const cef_string_t* name, struct _cef_value_t* value,
+                                    const cef_string_t* name,
+                                    struct _cef_value_t* value,
                                    cef_string_t* error);

  ///
@@ -248,7 +254,8 @@ typedef struct _cef_request_context_t {
  // |callback| will be executed on the UI thread after completion.
  ///
  void(CEF_CALLBACK* resolve_host)(struct _cef_request_context_t* self,
-      const cef_string_t* origin, struct _cef_resolve_callback_t* callback);
+                                   const cef_string_t* origin,
+                                   struct _cef_resolve_callback_t* callback);

  ///
  // Attempts to resolve |origin| to a list of associated IP addresses using
@@ -257,11 +264,11 @@ typedef struct _cef_request_context_t {
  // success. This function must be called on the browser process IO thread.
  ///
  cef_errorcode_t(CEF_CALLBACK* resolve_host_cached)(
-      struct _cef_request_context_t* self, const cef_string_t* origin,
+      struct _cef_request_context_t* self,
+      const cef_string_t* origin,
      cef_string_list_t resolved_ips);
 } cef_request_context_t;

-
 ///
 // Returns the global context object.
 ///
@@ -283,7 +290,6 @@ CEF_EXPORT cef_request_context_t* cef_create_context_shared(
    cef_request_context_t* other,
    struct _cef_request_context_handler_t* handler);

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_request_context_handler_capi.h
+++ b/include/capi/cef_request_context_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=9359e227c9d534c9c612d2ede790136461836501$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to provide handler implementations. The handler
 // instance will not be released until all objects related to the context have
@@ -56,7 +57,7 @@ typedef struct _cef_request_context_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called on the browser process IO thread to retrieve the cookie manager. If
@@ -87,13 +88,14 @@ typedef struct _cef_request_context_handler_t {
  ///
  int(CEF_CALLBACK* on_before_plugin_load)(
      struct _cef_request_context_handler_t* self,
-      const cef_string_t* mime_type, const cef_string_t* plugin_url,
-      int is_main_frame, const cef_string_t* top_origin_url,
+      const cef_string_t* mime_type,
+      const cef_string_t* plugin_url,
+      int is_main_frame,
+      const cef_string_t* top_origin_url,
      struct _cef_web_plugin_info_t* plugin_info,
      cef_plugin_policy_t* plugin_policy);
 } cef_request_context_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_request_handler_capi.h
+++ b/include/capi/cef_request_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=b6cbe39a8124a961036205864e7e6b2e1eb0bf6b$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
@@ -53,7 +55,6 @@
 extern "C" {
 #endif

-
 ///
 // Callback structure used for asynchronous continuation of url requests.
 ///
@@ -61,7 +62,7 @@ typedef struct _cef_request_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Continue the url request. If |allow| is true (1) the request will be
@@ -75,7 +76,6 @@ typedef struct _cef_request_callback_t {
  void(CEF_CALLBACK* cancel)(struct _cef_request_callback_t* self);
 } cef_request_callback_t;

-
 ///
 // Callback structure used to select a client certificate for authentication.
 ///
@@ -83,7 +83,7 @@ typedef struct _cef_select_client_certificate_callback_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Chooses the specified certificate for client certificate authentication.
@@ -94,7 +94,6 @@ typedef struct _cef_select_client_certificate_callback_t {
      struct _cef_x509certificate_t* cert);
 } cef_select_client_certificate_callback_t;

-
 ///
 // Implement this structure to handle events related to browser requests. The
 // functions of this structure will be called on the thread indicated.
@@ -103,7 +102,7 @@ typedef struct _cef_request_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called on the UI thread before browser navigation. Return true (1) to
@@ -116,8 +115,10 @@ typedef struct _cef_request_handler_t {
  // ERR_ABORTED.
  ///
  int(CEF_CALLBACK* on_before_browse)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      struct _cef_request_t* request, int is_redirect);
+                                      struct _cef_browser_t* browser,
+                                      struct _cef_frame_t* frame,
+                                      struct _cef_request_t* request,
+                                      int is_redirect);

  ///
  // Called on the UI thread before OnBeforeBrowse in certain limited cases
@@ -135,10 +136,13 @@ typedef struct _cef_request_handler_t {
  // true (1) to cancel the navigation or false (0) to allow the navigation to
  // proceed in the source browser's top-level frame.
  ///
-  int (CEF_CALLBACK *on_open_urlfrom_tab)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
+  int(CEF_CALLBACK* on_open_urlfrom_tab)(
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
      const cef_string_t* target_url,
-      cef_window_open_disposition_t target_disposition, int user_gesture);
+      cef_window_open_disposition_t target_disposition,
+      int user_gesture);

  ///
  // Called on the IO thread before a resource request is loaded. The |request|
@@ -149,8 +153,10 @@ typedef struct _cef_request_handler_t {
  //
  ///
  cef_return_value_t(CEF_CALLBACK* on_before_resource_load)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_request_t* request,
      struct _cef_request_callback_t* callback);

  ///
@@ -160,8 +166,10 @@ typedef struct _cef_request_handler_t {
  // modified in this callback.
  ///
  struct _cef_resource_handler_t*(CEF_CALLBACK* get_resource_handler)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_request_t* request);
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_request_t* request);

  ///
  // Called on the IO thread when a resource load is redirected. The |request|
@@ -172,8 +180,10 @@ typedef struct _cef_request_handler_t {
  // callback.
  ///
  void(CEF_CALLBACK* on_resource_redirect)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      struct _cef_request_t* request, struct _cef_response_t* response,
+                                           struct _cef_browser_t* browser,
+                                           struct _cef_frame_t* frame,
+                                           struct _cef_request_t* request,
+                                           struct _cef_response_t* response,
                                           cef_string_t* new_url);

  ///
@@ -183,8 +193,10 @@ typedef struct _cef_request_handler_t {
  // The |response| object cannot be modified in this callback.
  ///
  int(CEF_CALLBACK* on_resource_response)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      struct _cef_request_t* request, struct _cef_response_t* response);
+                                          struct _cef_browser_t* browser,
+                                          struct _cef_frame_t* frame,
+                                          struct _cef_request_t* request,
+                                          struct _cef_response_t* response);

  ///
  // Called on the IO thread to optionally filter resource response content.
@@ -192,8 +204,10 @@ typedef struct _cef_request_handler_t {
  // and cannot be modified in this callback.
  ///
  struct _cef_response_filter_t*(CEF_CALLBACK* get_resource_response_filter)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_request_t* request,
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_request_t* request,
      struct _cef_response_t* response);

  ///
@@ -203,9 +217,12 @@ typedef struct _cef_request_handler_t {
  // |received_content_length| is the number of response bytes actually read.
  ///
  void(CEF_CALLBACK* on_resource_load_complete)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, struct _cef_request_t* request,
-      struct _cef_response_t* response, cef_urlrequest_status_t status,
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      struct _cef_request_t* request,
+      struct _cef_response_t* response,
+      cef_urlrequest_status_t status,
      int64 received_content_length);

  ///
@@ -219,10 +236,16 @@ typedef struct _cef_request_handler_t {
  // the authentication information is available. Return false (0) to cancel the
  // request immediately.
  ///
-  int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame, int isProxy,
-      const cef_string_t* host, int port, const cef_string_t* realm,
-      const cef_string_t* scheme, struct _cef_auth_callback_t* callback);
+  int(CEF_CALLBACK* get_auth_credentials)(
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      int isProxy,
+      const cef_string_t* host,
+      int port,
+      const cef_string_t* realm,
+      const cef_string_t* scheme,
+      struct _cef_auth_callback_t* callback);

  ///
  // Called on the IO thread when JavaScript requests a specific storage quota
@@ -234,8 +257,10 @@ typedef struct _cef_request_handler_t {
  // immediately.
  ///
  int(CEF_CALLBACK* on_quota_request)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* origin_url,
-      int64 new_size, struct _cef_request_callback_t* callback);
+                                      struct _cef_browser_t* browser,
+                                      const cef_string_t* origin_url,
+                                      int64 new_size,
+                                      struct _cef_request_callback_t* callback);

  ///
  // Called on the UI thread to handle requests for URLs with an unknown
@@ -244,9 +269,10 @@ typedef struct _cef_request_handler_t {
  // YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR
  // OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
  ///
-  void (CEF_CALLBACK *on_protocol_execution)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      const cef_string_t* url, int* allow_os_execution);
+  void(CEF_CALLBACK* on_protocol_execution)(struct _cef_request_handler_t* self,
+                                            struct _cef_browser_t* browser,
+                                            const cef_string_t* url,
+                                            int* allow_os_execution);

  ///
  // Called on the UI thread to handle requests for URLs with an invalid SSL
@@ -256,9 +282,12 @@ typedef struct _cef_request_handler_t {
  // CefSettings.ignore_certificate_errors is set all invalid certificates will
  // be accepted without calling this function.
  ///
-  int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, cef_errorcode_t cert_error,
-      const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info,
+  int(CEF_CALLBACK* on_certificate_error)(
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      cef_errorcode_t cert_error,
+      const cef_string_t* request_url,
+      struct _cef_sslinfo_t* ssl_info,
      struct _cef_request_callback_t* callback);

  ///
@@ -275,8 +304,11 @@ typedef struct _cef_request_handler_t {
  // the server trusts.
  ///
  int(CEF_CALLBACK* on_select_client_certificate)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
-      int isProxy, const cef_string_t* host, int port,
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
+      int isProxy,
+      const cef_string_t* host,
+      int port,
      size_t certificatesCount,
      struct _cef_x509certificate_t* const* certificates,
      struct _cef_select_client_certificate_callback_t* callback);
@@ -286,7 +318,8 @@ typedef struct _cef_request_handler_t {
  // |plugin_path| is the path of the plugin that crashed.
  ///
  void(CEF_CALLBACK* on_plugin_crashed)(struct _cef_request_handler_t* self,
-      struct _cef_browser_t* browser, const cef_string_t* plugin_path);
+                                        struct _cef_browser_t* browser,
+                                        const cef_string_t* plugin_path);

  ///
  // Called on the browser process UI thread when the render view associated
@@ -301,11 +334,11 @@ typedef struct _cef_request_handler_t {
  // unexpectedly. |status| indicates how the process terminated.
  ///
  void(CEF_CALLBACK* on_render_process_terminated)(
-      struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
+      struct _cef_request_handler_t* self,
+      struct _cef_browser_t* browser,
      cef_termination_status_t status);
 } cef_request_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_resource_bundle_capi.h
+++ b/include/capi/cef_resource_bundle_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=82f2ce6f2ea3a8268ac69e33d304ace1a0e192b2$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used for retrieving resources from the resource bundle (*.pak)
 // files loaded by CEF during startup or via the cef_resource_bundle_tHandler
@@ -56,7 +57,7 @@ typedef struct _cef_resource_bundle_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the localized string for the specified |string_id| or an NULL
@@ -65,7 +66,8 @@ typedef struct _cef_resource_bundle_t {
  ///
  // The resulting string must be freed by calling cef_string_userfree_free().
  cef_string_userfree_t(CEF_CALLBACK* get_localized_string)(
-      struct _cef_resource_bundle_t* self, int string_id);
+      struct _cef_resource_bundle_t* self,
+      int string_id);

  ///
  // Retrieves the contents of the specified scale independent |resource_id|. If
@@ -76,7 +78,9 @@ typedef struct _cef_resource_bundle_t {
  // of valid resource ID values.
  ///
  int(CEF_CALLBACK* get_data_resource)(struct _cef_resource_bundle_t* self,
-      int resource_id, void** data, size_t* data_size);
+                                       int resource_id,
+                                       void** data,
+                                       size_t* data_size);

  ///
  // Retrieves the contents of the specified |resource_id| nearest the scale
@@ -89,17 +93,18 @@ typedef struct _cef_resource_bundle_t {
  // of valid resource ID values.
  ///
  int(CEF_CALLBACK* get_data_resource_for_scale)(
-      struct _cef_resource_bundle_t* self, int resource_id,
-      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+      struct _cef_resource_bundle_t* self,
+      int resource_id,
+      cef_scale_factor_t scale_factor,
+      void** data,
+      size_t* data_size);
 } cef_resource_bundle_t;

-
 ///
 // Returns the global resource bundle instance.
 ///
 CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_resource_bundle_handler_capi.h
+++ b/include/capi/cef_resource_bundle_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=cd94d8670c26bf17082629e5297407a716f01503$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to implement a custom resource bundle structure. See
 // CefSettings for additional options related to resource bundle loading. The
@@ -54,7 +55,7 @@ typedef struct _cef_resource_bundle_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Called to retrieve a localized translation for the specified |string_id|.
@@ -63,7 +64,8 @@ typedef struct _cef_resource_bundle_handler_t {
  // cef_pack_strings.h for a listing of valid string ID values.
  ///
  int(CEF_CALLBACK* get_localized_string)(
-      struct _cef_resource_bundle_handler_t* self, int string_id,
+      struct _cef_resource_bundle_handler_t* self,
+      int string_id,
      cef_string_t* string);

  ///
@@ -75,7 +77,9 @@ typedef struct _cef_resource_bundle_handler_t {
  // resource ID values.
  ///
  int(CEF_CALLBACK* get_data_resource)(
-      struct _cef_resource_bundle_handler_t* self, int resource_id, void** data,
+      struct _cef_resource_bundle_handler_t* self,
+      int resource_id,
+      void** data,
      size_t* data_size);

  ///
@@ -87,11 +91,13 @@ typedef struct _cef_resource_bundle_handler_t {
  // cef_pack_resources.h for a listing of valid resource ID values.
  ///
  int(CEF_CALLBACK* get_data_resource_for_scale)(
-      struct _cef_resource_bundle_handler_t* self, int resource_id,
-      cef_scale_factor_t scale_factor, void** data, size_t* data_size);
+      struct _cef_resource_bundle_handler_t* self,
+      int resource_id,
+      cef_scale_factor_t scale_factor,
+      void** data,
+      size_t* data_size);
 } cef_resource_bundle_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_resource_handler_capi.h
+++ b/include/capi/cef_resource_handler_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=cd9c4ed153ad4425ff43d640a81693e3c83817d2$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
@@ -49,7 +51,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to implement a custom request handler structure. The functions
 // of this structure will always be called on the IO thread.
@@ -58,7 +59,7 @@ typedef struct _cef_resource_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Begin processing the request. To handle the request return true (1) and
@@ -68,7 +69,8 @@ typedef struct _cef_resource_handler_t {
  // request return false (0).
  ///
  int(CEF_CALLBACK* process_request)(struct _cef_resource_handler_t* self,
-      struct _cef_request_t* request, struct _cef_callback_t* callback);
+                                     struct _cef_request_t* request,
+                                     struct _cef_callback_t* callback);

  ///
  // Retrieve response header information. If the response length is not known
@@ -81,9 +83,10 @@ typedef struct _cef_resource_handler_t {
  // URL. If an error occured while setting up the request you can call
  // set_error() on |response| to indicate the error condition.
  ///
-  void (CEF_CALLBACK *get_response_headers)(
-      struct _cef_resource_handler_t* self, struct _cef_response_t* response,
-      int64* response_length, cef_string_t* redirectUrl);
+  void(CEF_CALLBACK* get_response_headers)(struct _cef_resource_handler_t* self,
+                                           struct _cef_response_t* response,
+                                           int64* response_length,
+                                           cef_string_t* redirectUrl);

  ///
  // Read response data. If data is available immediately copy up to
@@ -93,7 +96,9 @@ typedef struct _cef_resource_handler_t {
  // data is available. To indicate response completion return false (0).
  ///
  int(CEF_CALLBACK* read_response)(struct _cef_resource_handler_t* self,
-      void* data_out, int bytes_to_read, int* bytes_read,
+                                   void* data_out,
+                                   int bytes_to_read,
+                                   int* bytes_read,
                                   struct _cef_callback_t* callback);

  ///
@@ -117,7 +122,6 @@ typedef struct _cef_resource_handler_t {
  void(CEF_CALLBACK* cancel)(struct _cef_resource_handler_t* self);
 } cef_resource_handler_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_response_capi.h
+++ b/include/capi/cef_response_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=3f0ed89d2320677780c2fd526be7fe6312580cd8$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure used to represent a web response. The functions of this structure
 // may be called on any thread.
@@ -53,7 +54,7 @@ typedef struct _cef_response_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is read-only.
@@ -128,13 +129,11 @@ typedef struct _cef_response_t {
                                     cef_string_multimap_t headerMap);
 } cef_response_t;

-
 ///
 // Create a new cef_response_t object.
 ///
 CEF_EXPORT cef_response_t* cef_response_create();

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_response_filter_capi.h
+++ b/include/capi/cef_response_filter_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=c7126418fc448f9f75e770fda8434613eed0930d$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to filter resource response content. The functions
 // of this structure will be called on the browser process IO thread.
@@ -53,7 +54,7 @@ typedef struct _cef_response_filter_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Initialize the response filter. Will only be called a single time. The
@@ -93,12 +94,15 @@ typedef struct _cef_response_filter_t {
  // Do not keep a reference to the buffers passed to this function.
  ///
  cef_response_filter_status_t(CEF_CALLBACK* filter)(
-      struct _cef_response_filter_t* self, void* data_in, size_t data_in_size,
-      size_t* data_in_read, void* data_out, size_t data_out_size,
+      struct _cef_response_filter_t* self,
+      void* data_in,
+      size_t data_in_size,
+      size_t* data_in_read,
+      void* data_out,
+      size_t data_out_size,
      size_t* data_out_written);
 } cef_response_filter_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_scheme_capi.h
+++ b/include/capi/cef_scheme_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=a920e25c5ca348dcc45965d53389c16a8a29b0ed$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
@@ -58,7 +60,7 @@ typedef struct _cef_scheme_registrar_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_scoped_t base;

  ///
  // Register a custom scheme. This function should not be called for the built-
@@ -87,31 +89,48 @@ typedef struct _cef_scheme_registrar_t {
  // is. For example, "scheme:///some%20text" will remain the same. Non-standard
  // scheme URLs cannot be used as a target for form submission.
  //
-  // If |is_local| is true (1) the scheme will be treated as local (i.e., with
-  // the same security rules as those applied to "file" URLs). Normal pages
-  // cannot link to or access local URLs. Also, by default, local URLs can only
-  // perform XMLHttpRequest calls to the same URL (origin + path) that
-  // originated the request. To allow XMLHttpRequest calls from a local URL to
-  // other URLs with the same origin set the
-  // CefSettings.file_access_from_file_urls_allowed value to true (1). To allow
-  // XMLHttpRequest calls from a local URL to all origins set the
-  // CefSettings.universal_access_from_file_urls_allowed value to true (1).
+  // If |is_local| is true (1) the scheme will be treated with the same security
+  // rules as those applied to "file" URLs. Normal pages cannot link to or
+  // access local URLs. Also, by default, local URLs can only perform
+  // XMLHttpRequest calls to the same URL (origin + path) that originated the
+  // request. To allow XMLHttpRequest calls from a local URL to other URLs with
+  // the same origin set the CefSettings.file_access_from_file_urls_allowed
+  // value to true (1). To allow XMLHttpRequest calls from a local URL to all
+  // origins set the CefSettings.universal_access_from_file_urls_allowed value
+  // to true (1).
  //
-  // If |is_display_isolated| is true (1) the scheme will be treated as display-
-  // isolated. This means that pages cannot display these URLs unless they are
-  // from the same scheme. For example, pages in another origin cannot create
-  // iframes or hyperlinks to URLs with this scheme.
+  // If |is_display_isolated| is true (1) the scheme can only be displayed from
+  // other content hosted with the same scheme. For example, pages in other
+  // origins cannot create iframes or hyperlinks to URLs with the scheme. For
+  // schemes that must be accessible from other schemes set this value to false
+  // (0), set |is_cors_enabled| to true (1), and use CORS "Access-Control-Allow-
+  // Origin" headers to further restrict access.
+  //
+  // If |is_secure| is true (1) the scheme will be treated with the same
+  // security rules as those applied to "https" URLs. For example, loading this
+  // scheme from other secure schemes will not trigger mixed content warnings.
+  //
+  // If |is_cors_enabled| is true (1) the scheme can be sent CORS requests. This
+  // value should be true (1) in most cases where |is_standard| is true (1).
+  //
+  // If |is_csp_bypassing| is true (1) the scheme can bypass Content-Security-
+  // Policy (CSP) checks. This value should be false (0) in most cases where
+  // |is_standard| is true (1).
  //
  // This function may be called on any thread. It should only be called once
  // per unique |scheme_name| value. If |scheme_name| is already registered or
  // if an error occurs this function will return false (0).
  ///
  int(CEF_CALLBACK* add_custom_scheme)(struct _cef_scheme_registrar_t* self,
-      const cef_string_t* scheme_name, int is_standard, int is_local,
-      int is_display_isolated);
+                                       const cef_string_t* scheme_name,
+                                       int is_standard,
+                                       int is_local,
+                                       int is_display_isolated,
+                                       int is_secure,
+                                       int is_cors_enabled,
+                                       int is_csp_bypassing);
 } cef_scheme_registrar_t;

-
 ///
 // Structure that creates cef_resource_handler_t instances for handling scheme
 // requests. The functions of this structure will always be called on the IO
@@ -121,7 +140,7 @@ typedef struct _cef_scheme_handler_factory_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Return a new resource handler instance to handle the request or an NULL
@@ -133,11 +152,12 @@ typedef struct _cef_scheme_handler_factory_t {
  ///
  struct _cef_resource_handler_t*(CEF_CALLBACK* create)(
      struct _cef_scheme_handler_factory_t* self,
-      struct _cef_browser_t* browser, struct _cef_frame_t* frame,
-      const cef_string_t* scheme_name, struct _cef_request_t* request);
+      struct _cef_browser_t* browser,
+      struct _cef_frame_t* frame,
+      const cef_string_t* scheme_name,
+      struct _cef_request_t* request);
 } cef_scheme_handler_factory_t;

-
 ///
 // Register a scheme handler factory with the global request context. An NULL
 // |domain_name| value for a standard scheme will cause the factory to match all
@@ -154,7 +174,8 @@ typedef struct _cef_scheme_handler_factory_t {
 // ory().
 ///
 CEF_EXPORT int cef_register_scheme_handler_factory(
-    const cef_string_t* scheme_name, const cef_string_t* domain_name,
+    const cef_string_t* scheme_name,
+    const cef_string_t* domain_name,
    cef_scheme_handler_factory_t* factory);

 ///
--- a/include/capi/cef_ssl_info_capi.h
+++ b/include/capi/cef_ssl_info_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=7489f3078e15407c3984f0b2393df3b0ddc045b0$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure representing SSL information.
 ///
@@ -54,14 +55,13 @@ typedef struct _cef_sslinfo_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns a bitmask containing any and all problems verifying the server
  // certificate.
  ///
-  cef_cert_status_t (CEF_CALLBACK *get_cert_status)(
-      struct _cef_sslinfo_t* self);
+  cef_cert_status_t(CEF_CALLBACK* get_cert_status)(struct _cef_sslinfo_t* self);

  ///
  // Returns the X.509 certificate.
@@ -70,7 +70,6 @@ typedef struct _cef_sslinfo_t {
      struct _cef_sslinfo_t* self);
 } cef_sslinfo_t;

-
 ///
 // Returns true (1) if the certificate status has any error, major or minor.
 ///
--- a/include/capi/cef_ssl_status_capi.h
+++ b/include/capi/cef_ssl_status_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=2aa604a0520a802ae3b10f5922d4a7ca48078785$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
@@ -46,7 +48,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure representing the SSL information for a navigation entry.
 ///
@@ -54,7 +55,7 @@ typedef struct _cef_sslstatus_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if the status is related to a secure SSL/TLS connection.
@@ -87,7 +88,6 @@ typedef struct _cef_sslstatus_t {
      struct _cef_sslstatus_t* self);
 } cef_sslstatus_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_stream_capi.h
+++ b/include/capi/cef_stream_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=4e127106e9b5fada6bf05ea6e29bc502bb2a1e0d$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Structure the client can implement to provide a custom stream reader. The
 // functions of this structure may be called on any thread.
@@ -53,19 +54,22 @@ typedef struct _cef_read_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Read raw binary data.
  ///
-  size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr,
-      size_t size, size_t n);
+  size_t(CEF_CALLBACK* read)(struct _cef_read_handler_t* self,
+                             void* ptr,
+                             size_t size,
+                             size_t n);

  ///
  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
  ///
-  int (CEF_CALLBACK *seek)(struct _cef_read_handler_t* self, int64 offset,
+  int(CEF_CALLBACK* seek)(struct _cef_read_handler_t* self,
+                          int64 offset,
                          int whence);

  ///
@@ -86,7 +90,6 @@ typedef struct _cef_read_handler_t {
  int(CEF_CALLBACK* may_block)(struct _cef_read_handler_t* self);
 } cef_read_handler_t;

-
 ///
 // Structure used to read data from a stream. The functions of this structure
 // may be called on any thread.
@@ -95,19 +98,22 @@ typedef struct _cef_stream_reader_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Read raw binary data.
  ///
-  size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr,
-      size_t size, size_t n);
+  size_t(CEF_CALLBACK* read)(struct _cef_stream_reader_t* self,
+                             void* ptr,
+                             size_t size,
+                             size_t n);

  ///
  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
  ///
-  int (CEF_CALLBACK *seek)(struct _cef_stream_reader_t* self, int64 offset,
+  int(CEF_CALLBACK* seek)(struct _cef_stream_reader_t* self,
+                          int64 offset,
                          int whence);

  ///
@@ -128,7 +134,6 @@ typedef struct _cef_stream_reader_t {
  int(CEF_CALLBACK* may_block)(struct _cef_stream_reader_t* self);
 } cef_stream_reader_t;

-
 ///
 // Create a new cef_stream_reader_t object from a file.
 ///
@@ -147,7 +152,6 @@ CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
 CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler(
    cef_read_handler_t* handler);

-
 ///
 // Structure the client can implement to provide a custom stream writer. The
 // functions of this structure may be called on any thread.
@@ -156,19 +160,22 @@ typedef struct _cef_write_handler_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Write raw binary data.
  ///
  size_t(CEF_CALLBACK* write)(struct _cef_write_handler_t* self,
-      const void* ptr, size_t size, size_t n);
+                              const void* ptr,
+                              size_t size,
+                              size_t n);

  ///
  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
  // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
  ///
-  int (CEF_CALLBACK *seek)(struct _cef_write_handler_t* self, int64 offset,
+  int(CEF_CALLBACK* seek)(struct _cef_write_handler_t* self,
+                          int64 offset,
                          int whence);

  ///
@@ -189,7 +196,6 @@ typedef struct _cef_write_handler_t {
  int(CEF_CALLBACK* may_block)(struct _cef_write_handler_t* self);
 } cef_write_handler_t;

-
 ///
 // Structure used to write data to a stream. The functions of this structure may
 // be called on any thread.
@@ -198,19 +204,22 @@ typedef struct _cef_stream_writer_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Write raw binary data.
  ///
  size_t(CEF_CALLBACK* write)(struct _cef_stream_writer_t* self,
-      const void* ptr, size_t size, size_t n);
+                              const void* ptr,
+                              size_t size,
+                              size_t n);

  ///
  // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
  // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
  ///
-  int (CEF_CALLBACK *seek)(struct _cef_stream_writer_t* self, int64 offset,
+  int(CEF_CALLBACK* seek)(struct _cef_stream_writer_t* self,
+                          int64 offset,
                          int whence);

  ///
@@ -231,7 +240,6 @@ typedef struct _cef_stream_writer_t {
  int(CEF_CALLBACK* may_block)(struct _cef_stream_writer_t* self);
 } cef_stream_writer_t;

-
 ///
 // Create a new cef_stream_writer_t object for a file.
 ///
@@ -244,7 +252,6 @@ CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file(
 CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler(
    cef_write_handler_t* handler);

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_string_visitor_capi.h
+++ b/include/capi/cef_string_visitor_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=2e8edddfd49aea615c7adf8d0d092a4865b79229$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure to receive string values asynchronously.
 ///
@@ -52,7 +53,7 @@ typedef struct _cef_string_visitor_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be executed.
@@ -61,7 +62,6 @@ typedef struct _cef_string_visitor_t {
                            const cef_string_t* string);
 } cef_string_visitor_t;

-
 #ifdef __cplusplus
 }
 #endif
--- a/include/capi/cef_task_capi.h
+++ b/include/capi/cef_task_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=344ba415349b4cc305f51cb9e22563b232433e25$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
@@ -44,7 +46,6 @@
 extern "C" {
 #endif

-
 ///
 // Implement this structure for asynchronous task execution. If the task is
 // posted successfully and if the associated message loop is still running then
@@ -57,7 +58,7 @@ typedef struct _cef_task_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Method that will be executed on the target thread.
@@ -65,7 +66,6 @@ typedef struct _cef_task_t {
  void(CEF_CALLBACK* execute)(struct _cef_task_t* self);
 } cef_task_t;

-
 ///
 // Structure that asynchronously executes tasks on the associated thread. It is
 // safe to call the functions of this structure on any thread.
@@ -79,7 +79,7 @@ typedef struct _cef_task_runner_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns true (1) if this object is pointing to the same task runner as
@@ -91,8 +91,7 @@ typedef struct _cef_task_runner_t {
  ///
  // Returns true (1) if this task runner belongs to the current thread.
  ///
-  int (CEF_CALLBACK *belongs_to_current_thread)(
-      struct _cef_task_runner_t* self);
+  int(CEF_CALLBACK* belongs_to_current_thread)(struct _cef_task_runner_t* self);

  ///
  // Returns true (1) if this task runner is for the specified CEF thread.
@@ -114,10 +113,10 @@ typedef struct _cef_task_runner_t {
  // specified delay.
  ///
  int(CEF_CALLBACK* post_delayed_task)(struct _cef_task_runner_t* self,
-      struct _cef_task_t* task, int64 delay_ms);
+                                       struct _cef_task_t* task,
+                                       int64 delay_ms);
 } cef_task_runner_t;

-
 ///
 // Returns the task runner for the current thread. Only CEF threads will have
 // task runners. An NULL reference will be returned if this function is called
@@ -131,7 +130,6 @@ CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread();
 CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
    cef_thread_id_t threadId);

-
 ///
 // Returns true (1) if called on the specified thread. Equivalent to using
 // cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread().
@@ -149,7 +147,8 @@ CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task);
 // using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task,
 // delay_ms).
 ///
-CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, cef_task_t* task,
+CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId,
+                                     cef_task_t* task,
                                     int64 delay_ms);

 #ifdef __cplusplus
--- a/include/capi/cef_thread_capi.h
+++ b/include/capi/cef_thread_capi.h
@@ -33,6 +33,8 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
+// $hash=d844086fc675680bfae12c3fa12a6886cc804816$
+//

 #ifndef CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
 #define CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
@@ -45,7 +47,6 @@
 extern "C" {
 #endif

-
 ///
 // A simple thread abstraction that establishes a message loop on a new thread.
 // The consumer uses cef_task_tRunner to execute code on the thread's message
@@ -61,7 +62,7 @@ typedef struct _cef_thread_t {
  ///
  // Base structure.
  ///
-  cef_base_t base;
+  cef_base_ref_counted_t base;

  ///
  // Returns the cef_task_tRunner that will execute code on this thread's
@@ -91,7 +92,6 @@ typedef struct _cef_thread_t {
  int(CEF_CALLBACK* is_running)(struct _cef_thread_t* self);
 } cef_thread_t;

-
 ///
 // Create and start a new thread. This function does not block waiting for the
 // thread to run initialization. |display_name| is the name that will be used to
@@ -103,10 +103,12 @@ typedef struct _cef_thread_t {
 // specifies how COM will be initialized for the thread. If |com_init_mode| is
 // set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI.
 ///
-CEF_EXPORT cef_thread_t* cef_thread_create(const cef_string_t* display_name,
-    cef_thread_priority_t priority, cef_message_loop_type_t message_loop_type,
-    int stoppable, cef_com_init_mode_t com_init_mode);
-
+CEF_EXPORT cef_thread_t* cef_thread_create(
+    const cef_string_t* display_name,
+    cef_thread_priority_t priority,
+    cef_message_loop_type_t message_loop_type,
+    int stoppable,
+    cef_com_init_mode_t com_init_mode);

 #ifdef __cplusplus
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Marshall Greenblatt	700dc254a7	Add "win-rt-app" command-line flag to disable MITIGATION_STRICT_HANDLE_CHECKS and avoid sandboxed renderer process crash in WinRT apps (issue #2274)	2017-09-29 11:23:31 +02:00
Marshall Greenblatt	934eaba67c	Add missing override keyword (issue #2224 )	2017-09-22 16:07:08 +02:00
Marshall Greenblatt	e260cbb922	Linux: Fix client termination (issue #2268 )	2017-09-21 16:08:29 +02:00
Marshall Greenblatt	857e7ebc07	Fix task runner checking	2017-09-21 13:57:40 +02:00
Marshall Greenblatt	88c82d244f	Windows: Add missing pe_image.lib to cef_sandbox.lib (issue #2266 )	2017-09-20 11:31:31 +02:00
Marshall Greenblatt	052c2d2722	Update to Chromium version 61.0.3163.91	2017-09-15 19:09:39 -04:00
Marshall Greenblatt	2265ad3ce2	Linux: Fix undefined reference to SettingsResetPromptController::ShowSettingsResetPrompt (issue #2240 )	2017-09-13 14:46:24 -04:00
Kaustubh Vats	cbcd0c4bca	macOS: Fix horizontal scrolling with trackpad (issue #2261 )	2017-09-13 13:03:23 -04:00
Marshall Greenblatt	416ffeb215	Windows: Remove get_syzygy_binaries.py build step (issue #2258 ) - Works around issue #2259	2017-09-12 15:55:57 -04:00
Marshall Greenblatt	281379bbbc	Windows: Remove get_syzygy_binaries.py build step (issue #2258 )	2017-09-12 15:02:06 -04:00
Marshall Greenblatt	1ec346dc4b	Linux: Fix 32-bit build fails with ld.gold: internal error in get_section_contents, at icf.cc:467 (issue #2256 )	2017-09-12 13:18:00 -04:00
Marshall Greenblatt	b9a2143541	Update to Chromium version 61.0.3163.79	2017-09-08 14:33:53 -04:00
Marshall Greenblatt	db997d194f	Add QUIC protocol configuration support (issue #2184 )	2017-09-05 14:23:08 -04:00
Marshall Greenblatt	d0138cbb07	Windows: Fix crash during window creation (see https://crbug.com/761389 )	2017-09-05 11:43:56 -04:00
Marshall Greenblatt	16be664a15	Windows: Wait for WM_NCDESTROY before calling OnBeforeClose (issue #2248 )	2017-08-31 18:14:02 -04:00
Marshall Greenblatt	15a2dd016a	Update to Chromium version 61.0.3163.59	2017-08-29 16:19:23 -04:00
Marshall Greenblatt	eef96a89d6	Fix crash loading chrome://net-internals	2017-08-10 16:58:53 -04:00
Marshall Greenblatt	7336129066	Fix Widevine DRM loading	2017-08-09 14:31:29 -04:00
Marshall Greenblatt	629d936795	views: Fix LabelButton size calculation	2017-08-08 16:17:22 -04:00
Marshall Greenblatt	2927c34f74	Update to Chromium version 61.0.3163.13	2017-07-28 23:34:43 -04:00
Marshall Greenblatt	f229796a39	Update to Chromium revision ff259bab (#488528 )	2017-07-28 18:30:34 -04:00
Marshall Greenblatt	6da2bbf229	Windows: Fix dialog loading for component build (issue #1617 )	2017-07-24 12:14:27 -04:00
Marshall Greenblatt	85c945bc00	Add missing deps for component build (issue #1617 )	2017-07-19 12:41:18 -04:00
Marshall Greenblatt	0c24e90b44	Fix errors on gclient sync of older release branches (issue #2211 )	2017-07-18 17:07:23 -04:00
Marshall Greenblatt	1aea3a06a5	Linux/Mac: Fix handling of command-line arguments (issue #2208 )	2017-07-18 13:57:04 -07:00
Marshall Greenblatt	796c7b6c59	Windows: Build cef_sandbox.lib with different GN args for official binary distributions (issue #2220 )	2017-07-18 15:52:18 -04:00
Marshall Greenblatt	700123d3eb	Add support for loading certificate revocation lists (issue #2213 )	2017-07-11 15:44:35 -04:00
Marshall Greenblatt	b216f427f6	Add component build support (issue #1617 )	2017-07-06 18:22:13 -04:00
Marshall Greenblatt	c080187908	Fix incorrect OSR browser display during navigation (issue #2209 )	2017-07-05 15:18:52 -04:00
Marshall Greenblatt	75acd20e9a	Fix OSR PDF mouse events after keyboard input (issue #2078 )	2017-06-30 16:30:30 -04:00
Marshall Greenblatt	8e69e3dcea	Windows/macOS: Fix incorrect clear of buffer during software rendering (issue #2197 )	2017-06-23 18:37:49 -04:00
Marshall Greenblatt	cb0dfccddc	Fix OSR PDF mouse wheel scrolling (issue #2078 )	2017-06-23 15:28:56 -04:00
Marshall Greenblatt	2773518869	Windows: cefclient: Fix ATL-related build errors (issue #2200 )	2017-06-19 15:00:18 +03:00
Marshall Greenblatt	70a01250e1	Linux: Don't pass NULL CefBrowser to PrintHandler::GetPdfPaperSize (issue #2199 )	2017-06-17 12:49:41 +03:00
Marshall Greenblatt	dce5d5c28f	Linux: Pass CefBrowser to CefPrintHandler callbacks (issue #2196 )	2017-06-15 08:58:54 -07:00
Marshall Greenblatt	5918d426b3	Fix gtest path (issue #2188 )	2017-06-13 17:09:59 +03:00
Marshall Greenblatt	943ffb217b	macOS: Fix error: unknown type name 'size_t'	2017-06-05 15:38:49 +03:00
Marshall Greenblatt	09f021be88	Linux: Update to debian jessie sysroots	2017-06-05 15:38:42 +03:00
Marshall Greenblatt	5c79944b31	Update to Chromium revision d483fb77 (#474934 ) - CefLifeSpanHandler::OnBeforePopup is now called on the UI thread. - Remove CefBrowserSettings.javascript_open_windows which is no longer supported.	2017-06-02 05:55:23 -07:00
Marshall Greenblatt	12150b43d2	Apply yapf formatting to all Python files (issue #2171 )	2017-05-28 15:04:18 +02:00
Marshall Greenblatt	59606b88d2	Update tooling to use yapf for Python file formatting (issue #2171 )	2017-05-28 15:03:42 +02:00
Marshall Greenblatt	d4f06e3806	Move matching h file to top of header list (issue #2171 )	2017-05-19 11:11:18 +02:00
Marshall Greenblatt	f6eb19f8d6	Fix discovery of the .clang-format file (issue #2171 )	2017-05-19 11:00:44 +02:00
Marshall Greenblatt	24e20aec0f	Fix duplicate definition of MSVC_PUSH_DISABLE_WARNING (issue #2171 )	2017-05-18 12:30:06 +02:00
Marshall Greenblatt	31d9407ee2	Apply clang-format to all C, C++ and ObjC files (issue #2171 )	2017-05-18 12:30:05 +02:00
Marshall Greenblatt	a566549e04	Update tooling to use clang-format (issue #2171 )	2017-05-18 12:30:04 +02:00
Nishant Kaushik	816f700d3e	Implement accessibility enhancements (issue #1217 ) - Add new CefBrowserHost::SetAccessibilityState method for toggling accessibility state when readers are detected by the client. - Add new CefAccessibilityHandler interface for the delivery of accessibility notifications to windowless (OSR) clients. - Fix delivery of CefFocusHandler callbacks to windowless clients. - cefclient: Add example windowless accessibility implementation on Windows and macOS. - cefclient: Automatically detect screen readers on Windows and macOS.	2017-05-12 18:28:25 +00:00
Marshall Greenblatt	64fcfa6068	Linux: cefclient: Add OSR drag&drop implementation (issue #2008 )	2017-05-11 12:06:32 -07:00
Marshall Greenblatt	67e23b472a	Expose drag image via CefDragData (issue #1715 )	2017-05-11 14:22:21 -04:00
Marshall Greenblatt	eaa0942690	Make CMake target settings private (issue #2007 )	2017-05-11 13:43:38 -04:00
Marshall Greenblatt	49d1fe3b30	CMake configuration improvements (issue #2120 ) - Windows: Fix excessive Ninja build warnings. - Windows: Fix ATL detection for different VC toolchain paths. - Windows: Fix Ninja Debug build when official build sandbox is enabled. - Update build tool version recommendations.	2017-05-11 13:19:35 -04:00
Marshall Greenblatt	eea39b8413	Windows: Fix wrong calling convention with gcc compiler (issue 1209)	2017-05-10 16:26:11 -04:00
Marshall Greenblatt	b28a6145a1	Make the CefAuthCallback::Continue password parameter optional (issue #1928 )	2017-05-10 12:16:53 -04:00
Marshall Greenblatt	7a02419cac	Fix crash when parent is destroyed during popup creation (issue #2041 )	2017-05-09 18:54:34 -04:00
Marshall Greenblatt	1347fec298	Remove unused function (issue #1853 )	2017-05-09 17:14:02 -04:00
Marshall Greenblatt	51e8c53f30	Remove CefForceShutdown and make failure to call CefShutdown a DCHECK instead (issue #1932 )	2017-05-09 15:52:52 -04:00
Marshall Greenblatt	77097ffab7	Remove the CefSettings.context_safety_implementation option (issue #1853 ). The default hash implementation will now always be used.	2017-05-09 15:29:27 -04:00
Andrew Warnick	96f9108343	Fix crash when a resource is cancelled due to browser closing (issue #2165 )	2017-05-09 15:30:48 +00:00
Marshall Greenblatt	e5ad5a8fcd	Fix DCHECK during Find (issue #2050 )	2017-05-05 15:34:20 -04:00
Marshall Greenblatt	86c329e790	Linux: Fix DCHECK during GPU feature info detection.	2017-05-04 16:58:47 -07:00
Marshall Greenblatt	3f970689a0	Popups must share the parent context to avoid crashes on parent browser destruction (issue #2162 )	2017-05-04 18:17:24 -04:00
Marshall Greenblatt	5a5b538af7	macOS: Fix incorrect creation of NSAutoreleasePool (issue #2160 )	2017-04-28 17:49:23 -04:00
Marshall Greenblatt	6d97cfb761	cefclient: macOS: Fix Xcode 5 compile error (issue #2116 )	2017-04-28 17:19:29 -04:00
Marshall Greenblatt	b85e69a94c	Add support for WebRTC screen sharing (issue #1065 )	2017-04-28 16:39:37 -04:00
Marshall Greenblatt	03e25c778a	Exit early when patches fail to apply (issue #2012 )	2017-04-27 15:20:50 -04:00
Marshall Greenblatt	6a603af993	Fix IndexedDB quota (issue #2070 )	2017-04-27 14:59:31 -04:00
Marshall Greenblatt	4fe6ac0d4b	Use git apply for applying patch files (issue #1825 )	2017-04-27 13:53:32 -04:00
Marshall Greenblatt	a2b8c250a8	Windows: Revert early chrome_elf crashpad initialization (issue #2122 )	2017-04-27 13:20:33 -04:00
Marshall Greenblatt	0a2b82757a	cefclient: macOS: Fix crash during shutdown from full-screen (issue #2158 )	2017-04-26 15:17:49 -04:00
Marshall Greenblatt	f440f850ef	cefclient: macOS: Fix CefBrowser leak during OSR shutdown (issue #2151 )	2017-04-26 15:05:12 -04:00
Marshall Greenblatt	f2b988a0ce	Windows: Fix crash on touch press text selection (issue #2149 )	2017-04-26 12:49:30 -04:00
Marshall Greenblatt	10fccbd6cf	Windows: Fix VS2008 compile error (issue #2155 )	2017-04-26 12:15:59 -04:00
Marshall Greenblatt	3f71138d64	Update to Chromium revision a106f0ab (#464641 ) - Remove CefWindowInfo.transparent_painting_enabled. Set CefBrowserSettings.background_color to an opaque or transparent value instead.	2017-04-24 15:14:47 -04:00
Marshall Greenblatt	2f6475c0d8	Fix print to PDF (issue #2129 )	2017-04-06 11:20:07 -04:00
Marshall Greenblatt	33b52839c6	cmake: macOS: Add Xcode 8.3 build support (issue #2140 )	2017-04-05 13:30:18 -04:00
Marshall Greenblatt	b66cddb919	cefclient: Linux: Fix order and timing of OSR key events (issue #2139 )	2017-04-04 12:39:01 -04:00
Marshall Greenblatt	aacc3aae9a	crash_server.py: Add support for chunked requests	2017-03-28 16:17:18 -04:00
Marshall Greenblatt	e7ac0d0ff5	Add PDF print scale factor setting (issue #2106 )	2017-03-16 17:47:40 -04:00
Marshall Greenblatt	c6838d8ca8	Fix DevTools inspect element at (issue #2115 )	2017-03-16 17:13:06 -04:00
Marshall Greenblatt	bab532b35b	Fix opening of popups from sandboxed iframes (issue #2121 )	2017-03-15 18:04:16 -04:00
Marshall Greenblatt	608f2d4170	Fix CHECK failure in CefBrowserHostImpl::DidFinishNavigation (issue #2125 )	2017-03-15 17:07:01 -04:00
Marshall Greenblatt	54647945f1	Update to Chromium revision 939b32ee (#454471 )	2017-03-08 13:33:05 -08:00
Marshall Greenblatt	fe68aee82c	Persist DevTools preferences with CefSettings.persist_user_preferences (issue #2077 )	2017-02-28 17:41:11 -05:00
Marshall Greenblatt	d2f48f6e08	Windows: Fix VS2010 compile error	2017-02-28 15:41:31 -05:00
Marshall Greenblatt	7de882ece3	cmake: Update target platform versions (issue #2109 ) - macOS: Allow selection of 10.11 SDK and set target version to 10.9 SDK. - Windows: Set target version to Windows 7.	2017-02-28 15:26:28 -05:00
Marshall Greenblatt	70f51c972a	Fix configuration of CefSettings.framework_dir_path (issue #2110 )	2017-02-28 14:40:03 -05:00
Marshall Greenblatt	c01f40017b	Windows: Fix AtExitManager assertion in SupervisedUserSettingsServiceFactory on shutdown when running with multi-threaded message loop (issue #1680 )	2017-02-28 13:16:26 -05:00
Marshall Greenblatt	8fa8af357b	views: Support styling of menus (issue #2102 )	2017-02-28 12:17:47 -05:00
Marshall Greenblatt	b08f0ed713	views: Fix layout calculation for LabelButton with mnemonics (issue #2102 )	2017-02-28 12:17:47 -05:00
Marshall Greenblatt	10f9a9484f	views: Support ink drop effect on buttons (issue #2102 )	2017-02-28 12:17:47 -05:00
Marshall Greenblatt	f8909fe9e0	README.md edited online with Bitbucket	2017-02-24 16:33:17 +00:00
Marshall Greenblatt	16125bdbbd	views: Support accelerators in MenuButton label (issue #2102 )	2017-02-23 12:47:20 -08:00
Marshall Greenblatt	6eaf11f07a	views: Support top menu switching with mouse and arrow keys (issue #2102 ) - cefclient: Add example ViewsMenuBar implementation and show top menu by default (specify `--hide-top-menu` to hide it).	2017-02-22 18:15:36 -05:00
Marshall Greenblatt	fbc8b983d5	Windows: Support crash upload URLs with query component (issue #1995 )	2017-02-21 13:38:50 -05:00
Marshall Greenblatt	c8c3ef4792	views: cefclient: Fix top menu placement (issue #2102 )	2017-02-17 21:42:15 -05:00
Marshall Greenblatt	6ed4fe96b8	views: Add groups and focus/blur callbacks (issue #2102 ) - cefclient: Only make menus focusable when ALT is pressed. - cefclient: Display sample top menu when passed the `--show-top-menu` command-line flag.	2017-02-17 21:08:55 -05:00
Marshall Greenblatt	bd1b80198f	views: Add support for accelerators (issue #2102 )	2017-02-17 14:11:19 -08:00
Marshall Greenblatt	e4867b5afb	Fix type comparison error	2017-02-16 18:31:07 -05:00
Marshall Greenblatt	b7556bdddf	Fix CefZipReader::GetFileLastModified (issue #1899 )	2017-02-15 18:44:42 -05:00
Marshall Greenblatt	c82ef82c21	Fix OSR popup transparency (issue #2099 )	2017-02-15 16:03:00 -05:00
Marshall Greenblatt	897c0f01ed	Simplify ownership of CefBrowserContext objects (issue #2083 )	2017-02-15 08:53:34 -08:00
Marshall Greenblatt	43001c0a94	Fix unreferenced variable warning (issue #2090 )	2017-02-14 10:15:12 -08:00
Marshall Greenblatt	54424d0edc	Fix crash during process shutdown (issue #2096 )	2017-02-14 10:09:42 -08:00
Marshall Greenblatt	feaca0ddf2	Simplify StoragePartition changes	2017-02-14 11:47:27 -05:00
Marshall Greenblatt	4054d66de0	Fix SupervisedUserSettingsService initialization (issue #2093 )	2017-02-13 17:12:57 -05:00
Marshall Greenblatt	903da5e452	Simplify OSR guest view implementation	2017-02-13 13:28:10 -05:00
Marshall Greenblatt	0a62a4dca8	Enable leak detection for translator test classes (issue #2090 )	2017-02-09 18:11:28 -05:00
Marshall Greenblatt	0afcb82ee6	Rename CefBase to CefBaseRefCounted (issue #2090 )	2017-02-09 17:50:59 -05:00
Marshall Greenblatt	07ba48b082	Add support for non-ref-counted interface classes (issue #2090 )	2017-02-09 17:50:46 -05:00
Marshall Greenblatt	9dd0ca2661	Allow empty value param to CefSetCrashKeyValue (issue #1995 )	2017-02-08 12:35:21 -05:00
Marshall Greenblatt	aa398d8798	macOS: Generate correct framework and Info.plist version numbers (issue #1969 )	2017-02-06 18:15:42 -05:00
Marshall Greenblatt	fda2f34c75	macOS: Fix incorrect OSR compositor resize in OnSwapCompositorFrame (issue #2065 )	2017-02-06 16:24:25 -05:00
Marshall Greenblatt	661fa722a7	macOS: Add option for forwarding browser process crashes to the system crash reporter (issue #1995 )	2017-02-06 15:06:25 -05:00
Marshall Greenblatt	caef479ae0	macOS: Update xib files to 10.9 deployment target	2017-02-02 18:16:43 -05:00
Marshall Greenblatt	d6531b9fe6	macOS: cefclient: Create Tests menu with Interface Builder	2017-02-02 15:43:41 -05:00
Marshall Greenblatt	94f604975d	Fix localization of default context menu labels (issue #2081 )	2017-02-01 15:24:20 -05:00
Marshall Greenblatt	a90b50f1ff	Fix KeyedServiceFactory assertion during shutdown (issue #2083 )	2017-01-31 17:23:27 -05:00
Marshall Greenblatt	30451b7ca5	Fix crash using WebRTC with TLS certs (issue #2080 )	2017-01-31 15:25:12 -05:00
Marshall Greenblatt	5c160e018b	Windows: Fix command line parsing for crash handler (issue #1995 )	2017-01-30 16:21:12 -05:00
Marshall Greenblatt	a56ac9782e	macOS: Support crash reporting from unbundled apps (issue #1532 )	2017-01-27 14:16:04 -05:00
Marshall Greenblatt	dda50912ed	macOS: Allow configuration of framework path (issue #1532 )	2017-01-26 19:14:56 -05:00
Marshall Greenblatt	18ce862ad8	Standardize product/version/platform crash keys (issue #1995 )	2017-01-25 13:37:12 -05:00
Marshall Greenblatt	819dcdf461	Fix potential OSR crash on renderer process recreation (issue #2082 )	2017-01-25 12:34:42 -05:00
Marshall Greenblatt	41a02dbe08	Add is_main_frame argument to CefRequestContextHandler::OnBeforePluginLoad (issue #2015 )	2017-01-24 18:53:08 -05:00
Marshall Greenblatt	b7b145fa4f	Update to Chromium revision ad51088c (#444943 )	2017-01-24 16:53:09 -05:00
Marshall Greenblatt	9d48a4f80e	Fix CefRequestHandler::OnCertificateError callback trigger (issue #2019 )	2017-01-17 12:49:23 -05:00
Marshall Greenblatt	da6f2864c2	cefclient: Fix typo in TempWindow comments	2017-01-17 12:46:49 -05:00
Marshall Greenblatt	5f4190ff75	Add CefContextMenuParams::GetTitleText method (issue #2030 )	2017-01-17 12:43:49 -05:00
Marshall Greenblatt	3f0c94f7e6	Windows: Fix white flash during browser creation (issue #1984 )	2017-01-13 16:57:54 -05:00
Marshall Greenblatt	914fc6f7af	Windows: Fix AppName and ExternalHandler usage in crash_reporter.cfg (issue #1995 )	2017-01-13 15:44:43 -05:00
Marshall Greenblatt	7bdfe79e35	Add product name and version to crash_reporter.cfg (issue #1995 )	2017-01-12 13:23:28 -05:00
Marshall Greenblatt	a834487177	Improve crashpad integration (issue #1995 ) - Crash reporting is enabled and configured using a "crash_reporter.cfg" file. See comments in include/cef_crash_util.h and tools/crash_server.py for usage.	2017-01-10 18:40:31 -05:00
Marshall Greenblatt	c990b5d877	Update copyright year on generated files	2017-01-10 18:00:30 -05:00
Marshall Greenblatt	9928036f63	Windows: Fix behavior of frameless windows with Views. - Don't set InitParams::TRANSLUCENT_WINDOW. Setting this resulted in the WS_EX_COMPOSITED style being added and the WS_THICKFRAME style being removed, which disabled Aero Snap. - Remove the non-client border to get a completely frameless window. Having a border is problematic because the top is drawn by Windows while the rest is drawn black. Having Windows draw part of the border is required to enable the window drop shadow (see HWNDMessageHandler::SetDwmFrameExtension). - Delete the remove_caption patches which are no longer required.	2016-12-14 06:59:13 -08:00
Marshall Greenblatt	48908c9195	Windows: Add missing crashpad initialization (issue #1995 )	2016-12-05 14:29:54 +01:00
Marshall Greenblatt	03ed733800	Windows: Fix missing InsertAllocatorDispatch symbol in cef_sandbox.lib (issue #2044 )	2016-11-30 19:54:08 -05:00
Marshall Greenblatt	c1a1dbdb7d	Windows: Fix x64 build conversion from 'size_t' to 'int' error (issue #2054 )	2016-11-30 15:23:04 -05:00