Update to Chromium version 88.0.4324.182

Switch to using g_main_context_default() in MainMessageLoopMultithreadedGtk. As of M86
(https://crrev.com/b960daf4e6) Chromium now creates its own context in MessagePumpGlib so
we can use the default context in cefclient. This is also more "correct" from a GTK usage
perspective. As part of this change all GTK dialogs and callbacks are now executed on the
main thread instead of the UI thread (note that these are the same thread when not using
multi-threaded-message-loop).

BUILD.gn

@@ -98,6 +98,7 @@ import("//build/config/features.gni")
 import("//build/config/locales.gni")
 import("//build/config/sanitizers/sanitizers.gni")
 import("//build/config/ui.gni")
+import("//cef/cef_repack_locales.gni")
 import("//chrome/common/features.gni")
 import("//content/public/app/mac_helpers.gni")
 import("//extensions/buildflags/buildflags.gni")
@@ -125,6 +126,7 @@ if (is_mac) {
   import("//build/config/mac/rules.gni")
   import("//build/util/version.gni")
   import("//media/cdm/library_cdm/cdm_paths.gni")
+  import("//build/config/mac/base_rules.gni")
 
   # Template to compile .xib and .storyboard files.
   #
@@ -261,6 +263,12 @@ if (is_clang) {
   assert(!clang_use_chrome_plugins)
 }
 
+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.
+  assert(enable_dsyms)
+}
+
 
 #
 # Local variables.
@@ -454,8 +462,6 @@ static_library("libcef_static") {
     "libcef/browser/chrome/chrome_browser_main_extra_parts_cef.h",
     "libcef/browser/chrome/chrome_content_browser_client_cef.cc",
     "libcef/browser/chrome/chrome_content_browser_client_cef.h",
-    "libcef/browser/chrome/chrome_context_menu_handler.cc",
-    "libcef/browser/chrome/chrome_context_menu_handler.h",
     "libcef/browser/chrome_crash_reporter_client_stub.cc",
     "libcef/browser/context.cc",
     "libcef/browser/context.h",
@@ -481,8 +487,6 @@ static_library("libcef_static") {
     "libcef/browser/extensions/api/storage/sync_value_store_cache.h",
     "libcef/browser/extensions/api/tabs/tabs_api.cc",
     "libcef/browser/extensions/api/tabs/tabs_api.h",
-    "libcef/browser/extensions/alloy_extensions_util.cc",
-    "libcef/browser/extensions/alloy_extensions_util.h",
     "libcef/browser/extensions/browser_extensions_util.cc",
     "libcef/browser/extensions/browser_extensions_util.h",
     "libcef/browser/extensions/browser_platform_delegate_background.cc",
@@ -624,6 +628,8 @@ static_library("libcef_static") {
     "libcef/browser/print_settings_impl.h",
     "libcef/browser/printing/constrained_window_views_client.cc",
     "libcef/browser/printing/constrained_window_views_client.h",
+    "libcef/browser/printing/printing_message_filter.cc",
+    "libcef/browser/printing/printing_message_filter.h",
     "libcef/browser/printing/print_view_manager.cc",
     "libcef/browser/printing/print_view_manager.h",
     "libcef/browser/process_util_impl.cc",
@@ -634,8 +640,6 @@ static_library("libcef_static") {
     "libcef/browser/scheme_impl.cc",
     "libcef/browser/server_impl.cc",
     "libcef/browser/server_impl.h",
-    "libcef/browser/simple_menu_model_impl.cc",
-    "libcef/browser/simple_menu_model_impl.h",
     "libcef/browser/speech_recognition_manager_delegate.cc",
     "libcef/browser/speech_recognition_manager_delegate.h",
     "libcef/browser/ssl_host_state_delegate.cc",
@@ -715,8 +719,6 @@ static_library("libcef_static") {
     "libcef/common/net/upload_data.h",
     "libcef/common/net/upload_element.cc",
     "libcef/common/net/upload_element.h",
-    "libcef/common/net/url_util.cc",
-    "libcef/common/net/url_util.h",
     "libcef/common/net_service/net_service_util.cc",
     "libcef/common/net_service/net_service_util.h",
     "libcef/common/parser_impl.cc",
@@ -1058,17 +1060,13 @@ static_library("libcef_static") {
   }
 
   if (toolkit_views) {
+    deps += [
+      "//ui/views",
+    ]
+  }
+
+  if (use_aura) {
     sources += [
-      "libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc",
-      "libcef/browser/chrome/views/browser_platform_delegate_chrome_views.h",
-      "libcef/browser/chrome/views/chrome_browser_frame.cc",
-      "libcef/browser/chrome/views/chrome_browser_frame.h",
-      "libcef/browser/chrome/views/chrome_browser_view.cc",
-      "libcef/browser/chrome/views/chrome_browser_view.h",
-      "libcef/browser/chrome/views/toolbar_view_impl.cc",
-      "libcef/browser/chrome/views/toolbar_view_impl.h",
-      "libcef/browser/chrome/views/toolbar_view_view.cc",
-      "libcef/browser/chrome/views/toolbar_view_view.h",
       "libcef/browser/native/window_delegate_view.cc",
       "libcef/browser/native/window_delegate_view.h",
       "libcef/browser/views/basic_label_button_impl.cc",
@@ -1129,106 +1127,84 @@ static_library("libcef_static") {
 
       # Part of //ui/views:test_support which is testingonly.
       "//ui/views/test/desktop_test_views_delegate.h",
+      "//ui/views/test/desktop_test_views_delegate_aura.cc",
       "//ui/views/test/test_views_delegate.h",
+      "//ui/views/test/test_views_delegate_aura.cc",
 
       # Support for UI input events.
       # Part of //ui/base:test_support which is testingonly.
       "//ui/base/test/ui_controls.h",
+      "//ui/base/test/ui_controls_aura.cc",
+      "//ui/aura/test/ui_controls_factory_aura.h",
     ]
 
+    if (is_linux && !use_x11) {
+      sources += [
+        "//ui/aura/test/ui_controls_factory_ozone.cc",
+        "//ui/events/test/events_test_utils.cc"
+      ]
+    }
+
     deps += [
+      "//ui/aura",
       "//ui/events",
       "//ui/strings",
-      "//ui/views",
-      "//ui/views/controls/webview",
+      "//ui/wm",
+      "//ui/wm/public",
     ]
 
-    if (use_aura) {
-      sources += [
-        "libcef/browser/native/browser_platform_delegate_native_aura.cc",
-        "libcef/browser/native/browser_platform_delegate_native_aura.h",
-        "libcef/browser/views/view_util_aura.cc",
-
-        # Part of //ui/views:test_support which is testingonly.
-        "//ui/views/test/desktop_test_views_delegate_aura.cc",
-        "//ui/views/test/test_views_delegate_aura.cc",
-
-        # Support for UI input events.
-        # Part of //ui/base:test_support which is testingonly.
-        "//ui/base/test/ui_controls_aura.cc",
-        "//ui/aura/test/ui_controls_factory_aura.h",
-      ]
-
+    if (toolkit_views) {
       deps += [
-        "//ui/aura",
-        "//ui/wm",
-        "//ui/wm/public",
+        "//ui/views/controls/webview",
+      ]
+    }
+    
+    if (is_win) {
+      sources += [
+        # Support for UI input events.
+        # Part of //base/test:test_config which is testingonly.
+        "//base/test/test_switches.cc",
+        "//base/test/test_switches.h",
+        "//base/test/test_timeouts.cc",
+        "//base/test/test_timeouts.h",
+        # Part of //ui/aura:test_support which is testingonly.
+        "//ui/aura/test/ui_controls_factory_aurawin.cc",
+        # Part of //ui/base:test_support which is testingonly.
+        "//ui/base/test/ui_controls_internal_win.cc",
+        "//ui/base/test/ui_controls_internal_win.h",
+      ]
+    }
+
+    if (is_linux) {
+      sources += [
+        # Support for UI input events.
+        # Part of //ui/aura:test_support which is testingonly.
+        "//ui/aura/test/aura_test_utils.cc",
+        "//ui/aura/test/aura_test_utils.h",
+        # Part of //ui/events:test_support which is testingonly.
+        "//ui/events/test/x11_event_waiter.cc",
+        "//ui/events/test/x11_event_waiter.h",
       ]
 
-      if (is_win) {
+      if (use_x11) {
         sources += [
           # Support for UI input events.
-          # Part of //base/test:test_config which is testingonly.
-          "//base/test/test_switches.cc",
-          "//base/test/test_switches.h",
-          "//base/test/test_timeouts.cc",
-          "//base/test/test_timeouts.h",
+          # Part of //ui/base/x:test_support which is testingonly.
+          "//ui/base/x/test/x11_ui_controls_test_helper.cc",
+          "//ui/base/x/test/x11_ui_controls_test_helper.h",
           # Part of //ui/aura:test_support which is testingonly.
-          "//ui/aura/test/ui_controls_factory_aurawin.cc",
-          # Part of //ui/base:test_support which is testingonly.
-          "//ui/base/test/ui_controls_internal_win.cc",
-          "//ui/base/test/ui_controls_internal_win.h",
+          "//ui/aura/test/x11_event_sender.h",
+          # Part of //ui/views:test_support which is testingonly.
+          "//ui/views/test/ui_controls_factory_desktop_aurax11.cc",
+          "//ui/views/test/ui_controls_factory_desktop_aurax11.h",
         ]
       }
-
-      if (is_linux) {
-        sources += [
-          # Support for UI input events.
-          # Part of //ui/aura:test_support which is testingonly.
-          "//ui/aura/test/aura_test_utils.cc",
-          "//ui/aura/test/aura_test_utils.h",
-          # Part of //ui/events:test_support which is testingonly.
-          "//ui/events/test/x11_event_waiter.cc",
-          "//ui/events/test/x11_event_waiter.h",
-        ]
-
-        if (use_x11) {
-          sources += [
-            # Support for UI input events.
-            # Part of //ui/base/x:test_support which is testingonly.
-            "//ui/base/x/test/x11_ui_controls_test_helper.cc",
-            "//ui/base/x/test/x11_ui_controls_test_helper.h",
-            # Part of //ui/aura:test_support which is testingonly.
-            "//ui/aura/test/x11_event_sender.h",
-            # Part of //ui/views:test_support which is testingonly.
-            "//ui/views/test/ui_controls_factory_desktop_aurax11.cc",
-            "//ui/views/test/ui_controls_factory_desktop_aurax11.h",
-          ]
-        } else {
-          sources += [
-            # Support for UI input events.
-            # Part of //ui/base:test_support which is testingonly.
-            "//ui/aura/test/ui_controls_factory_ozone.cc",
-            # Part of //ui//events:test_support which is testingonly.
-            "//ui/events/test/events_test_utils.cc"
-          ]
-        }
-      }
     }
 
-    if (is_mac) {
+    if (is_win || is_linux) {
       sources += [
-        "libcef/browser/views/view_util_mac.mm",
-
-        # Part of //ui/views:test_support which is testingonly.
-        "//ui/views/test/desktop_test_views_delegate_mac.mm",
-        "//ui/views/test/test_views_delegate_mac.mm",
-
-        # Support for UI input events.
-        # Part of //ui/base:test_support which is testingonly.
-        "//ui/base/test/ui_controls_mac.mm",
-        # Part of //ui//events:test_support which is testingonly.
-        "//ui/events/test/cocoa_test_event_utils.mm",
+        "libcef/browser/native/browser_platform_delegate_native_aura.cc",
+        "libcef/browser/native/browser_platform_delegate_native_aura.h",
       ]
     }
   } else {
@@ -1307,8 +1283,119 @@ if (is_mac) {
 # Resource grit/pack targets.
 #
 
-# Included in locales/*.pak via //chrome/chrome_repack_locales.gni.
+# Helper for generating scaled resource packs.
+template("cef_pak_scaled") {
+  percent = invoker.percent
+
+  repack("pak_${target_name}") {
+    # 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/chrome/renderer_resources_${percent}_percent.pak",
+      "$root_gen_dir/components/components_resources_${percent}_percent.pak",
+      "$root_gen_dir/content/app/resources/content_resources_${percent}_percent.pak",
+      "$root_gen_dir/extensions/extensions_browser_resources_${percent}_percent.pak",
+      "$root_gen_dir/third_party/blink/public/resources/blink_scaled_resources_${percent}_percent.pak",
+      "$root_gen_dir/ui/resources/ui_resources_${percent}_percent.pak",
+    ]
+
+    # Use public_deps so that generated grit headers are discoverable from
+    # the libcef_static target. Grit deps that generate .cc files must be
+    # listed both here and in the libcef_static target.
+    public_deps = [
+      "//chrome/renderer:resources",
+      "//components/resources:components_scaled_resources",
+      "//content/app/resources",
+      "//extensions:extensions_browser_resources",
+      "//third_party/blink/public:scaled_resources",
+      "//ui/resources:ui_resources_grd",
+    ]
+
+    deps = [
+      # This repack target generates the blink_scaled_resources_*_percent.pak
+      # file but doesn't expose the public_deps required by make_pack_header.
+      "//third_party/blink/public:scaled_resources_${percent}_percent",
+    ]
+
+    if (toolkit_views) {
+      sources += [
+        "$root_gen_dir/ui/views/resources/views_resources_${percent}_percent.pak"
+      ]
+
+      public_deps += [
+        "//ui/views/resources:resources_grd"
+      ]
+    }
+
+    output = "$root_out_dir/cef_${percent}_percent.pak"
+  }
+}
+
+# Generate cef_100_percent.pak.
+cef_pak_scaled("100_percent") {
+  percent = "100"
+}
+
+# Generate cef_200_percent.pak.
+cef_pak_scaled("200_percent") {
+  percent = "200"
+}
+
+# Generate devtools_resources.pak.
+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/content/browser/devtools/devtools_resources.pak",
+    "$root_gen_dir/third_party/blink/public/resources/inspector_overlay_resources.pak",
+  ]
+
+  # Use public_deps so that generated grit headers are discoverable from
+  # the libcef_static target. Grit deps that generate .cc files must be
+  # listed both here and in the libcef_static target.
+  public_deps = [
+    "//content/browser/devtools:devtools_resources",
+    "//third_party/blink/public:devtools_inspector_resources",
+  ]
+
+  output = "$root_out_dir/devtools_resources.pak"
+}
+
+# Generate cef_extensions.pak.
+repack("pak_extensions") {
+  # 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/chrome/component_extension_resources.pak",
+    "$root_gen_dir/content/browser/resources/media/media_internals_resources.pak",
+    "$root_gen_dir/content/browser/webrtc/resources/webrtc_internals_resources.pak",
+    "$root_gen_dir/extensions/extensions_renderer_resources.pak",
+    "$root_gen_dir/extensions/extensions_resources.pak",
+    "$root_gen_dir/mojo/public/js/mojo_bindings_resources.pak",
+    "$root_gen_dir/ui/resources/webui_generated_resources.pak",
+    "$root_gen_dir/ui/resources/webui_resources.pak",
+  ]
+
+  # Use public_deps so that generated grit headers are discoverable from
+  # the libcef_static target. Grit deps that generate .cc files must be
+  # listed both here and in the libcef_static target.
+  public_deps = [
+    "//chrome/browser/resources:component_extension_resources",
+    "//content/browser/resources/media:media_internals_resources",
+    "//content/browser/webrtc/resources",
+    "//extensions:extensions_renderer_resources",
+    "//extensions:extensions_resources_grd",
+    "//mojo/public/js:resources",
+    "//ui/resources:webui_generated_resources_grd",
+    "//ui/resources:webui_resources_grd",
+  ]
+
+  output = "$root_out_dir/cef_extensions.pak"
+}
+
 grit("cef_strings") {
+  visibility = [ ":*" ]
+
   source = "libcef/resources/cef_strings.grd"
   outputs = [
     "grit/cef_strings.h",
@@ -1319,8 +1406,22 @@ grit("cef_strings") {
   }
 }
 
-# Included in resources.pak via //chrome/chrome_paks.gni.
+# Generate locales/<locale>.pak.
+# See cef_repack_locales.gni for the list of input pak files and deps.
+cef_repack_locales("repack_locales_pack") {
+  visibility = [ ":*" ]
+
+  input_locales = locales
+
+  if (is_mac) {
+    output_locales = locales_as_mac_outputs
+  } else {
+    output_locales = locales
+  }
+}
+
 grit("cef_resources") {
+  visibility = [ ":*" ]
   source = "libcef/resources/cef_resources.grd"
   outputs = [
     "grit/cef_resources.h",
@@ -1332,11 +1433,54 @@ grit("cef_resources") {
   ]
 }
 
+# Generate cef.pak.
+repack("pak") {
+  # 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/base/tracing/protos/tracing_proto_resources.pak",
+    "$root_gen_dir/chrome/browser_resources.pak",
+    "$root_gen_dir/chrome/dev_ui_browser_resources.pak",
+    "$root_gen_dir/chrome/net_internals_resources.pak",
+    "$root_gen_dir/chrome/print_preview_resources.pak",
+    "$root_gen_dir/chrome/common_resources.pak",
+    "$root_gen_dir/components/components_resources.pak",
+    "$root_gen_dir/components/dev_ui_components_resources.pak",
+    "$root_gen_dir/cef/cef_resources.pak",
+    "$root_gen_dir/content/browser/tracing/tracing_resources.pak",
+    "$root_gen_dir/content/content_resources.pak",
+    "$root_gen_dir/content/dev_ui_content_resources.pak",
+    "$root_gen_dir/net/net_resources.pak",
+    "$root_gen_dir/third_party/blink/public/resources/blink_resources.pak",
+  ]
+
+  # Use public_deps so that generated grit headers are discoverable from
+  # the libcef_static target. Grit deps that generate .cc files must be
+  # listed both here and in the libcef_static target.
+  public_deps = [
+    "//base/tracing/protos:chrome_track_event_resources",
+    "//chrome/browser:dev_ui_browser_resources",
+    "//chrome/browser:resources",
+    "//chrome/browser/resources/net_internals:net_internals_resources",
+    "//chrome/browser/resources/print_preview:print_preview_resources",
+    "//chrome/common:resources",
+    "//components/resources:components_resources",
+    "//components/resources:dev_ui_components_resources",
+    ":cef_resources",
+    "//content/browser/tracing:resources",
+    "//content:content_resources",
+    "//content:dev_ui_content_resources",
+    "//net:net_resources",
+    "//third_party/blink/public:resources",
+  ]
+
+  output = "$root_out_dir/cef.pak"
+}
+
 # Helper for generating pack header files.
 template("make_pack_header") {
   assert(defined(invoker.header))
   assert(defined(invoker.inputs))
-  assert(defined(invoker.deps))
 
   action("make_pack_header_${target_name}") {
     script = "tools/make_pack_header.py"
@@ -1347,7 +1491,16 @@ template("make_pack_header") {
     args = rebase_path(outputs, root_build_dir) +
            rebase_path(inputs, root_build_dir)
 
-    deps = invoker.deps
+    deps = [
+      # List all targets that generate pack files here. The grit targets that
+      # generate |inputs| will be picked up via public_deps.
+      ":pak",
+      ":pak_100_percent",
+      ":pak_200_percent",
+      ":pak_devtools",
+      ":pak_extensions",
+      ":repack_locales_pack",
+    ]
   }
 }
 
@@ -1361,55 +1514,25 @@ make_pack_header("resources") {
     "$root_gen_dir/chrome/grit/common_resources.h",
     "$root_gen_dir/chrome/grit/component_extension_resources.h",
     "$root_gen_dir/chrome/grit/dev_ui_browser_resources.h",
+    "$root_gen_dir/chrome/grit/net_internals_resources.h",
+    "$root_gen_dir/chrome/grit/print_preview_resources.h",
     "$root_gen_dir/chrome/grit/renderer_resources.h",
     "$root_gen_dir/components/grit/components_resources.h",
     "$root_gen_dir/components/grit/dev_ui_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/browser/webrtc/resources/grit/webrtc_internals_resources.h",
     "$root_gen_dir/content/grit/content_resources.h",
     "$root_gen_dir/content/grit/dev_ui_content_resources.h",
     "$root_gen_dir/extensions/grit/extensions_browser_resources.h",
     "$root_gen_dir/extensions/grit/extensions_renderer_resources.h",
     "$root_gen_dir/extensions/grit/extensions_resources.h",
-    "$root_gen_dir/mojo/public/js/grit/mojo_bindings_resources.h",
     "$root_gen_dir/net/grit/net_resources.h",
     "$root_gen_dir/third_party/blink/public/resources/grit/blink_resources.h",
     "$root_gen_dir/ui/resources/grit/ui_resources.h",
     "$root_gen_dir/ui/resources/grit/webui_generated_resources.h",
     "$root_gen_dir/ui/resources/grit/webui_resources.h",
+    "$root_gen_dir/ui/views/resources/grit/views_resources.h",
   ]
-
-  deps = [
-    ":cef_resources",
-    "//base/tracing/protos:chrome_track_event_resources",
-    "//chrome/browser:dev_ui_browser_resources",
-    "//chrome/browser:resources",
-    "//chrome/browser/resources:component_extension_resources",
-    "//chrome/common:resources",
-    "//chrome/renderer:resources",
-    "//components/resources:components_resources",
-    "//components/resources:dev_ui_components_resources",
-    "//content/browser/devtools:devtools_resources",
-    "//content/browser/tracing:resources",
-    "//content/browser/webrtc/resources",
-    "//content:content_resources",
-    "//content:dev_ui_content_resources",
-    "//extensions:extensions_browser_resources",
-    "//extensions:extensions_renderer_resources",
-    "//extensions:extensions_resources_grd",
-    "//mojo/public/js:resources",
-    "//net:net_resources",
-    "//third_party/blink/public:resources",
-    "//ui/resources:ui_resources_grd",
-    "//ui/resources:webui_generated_resources_grd",
-    "//ui/resources:webui_resources_grd",
-  ]
-
-  if (toolkit_views) {
-    inputs += [ "$root_gen_dir/ui/views/resources/grit/views_resources.h" ]
-    deps += [ "//ui/views/resources:resources_grd" ]
-  }
 }
 
 # Generate cef_pack_strings.h.
@@ -1429,23 +1552,6 @@ make_pack_header("strings") {
     "$root_gen_dir/third_party/blink/public/strings/grit/blink_strings.h",
     "$root_gen_dir/ui/strings/grit/ui_strings.h",
   ]
-
-  deps = [
-    ":cef_strings",
-    "//chrome/app:chromium_strings",
-    "//chrome/app:generated_resources",
-    "//chrome/app/resources:locale_settings",
-    "//chrome/app/resources:platform_locale_settings",
-    "//components/omnibox/resources:omnibox_resources",
-    "//components/strings:components_chromium_strings",
-    "//components/strings:components_locale_settings",
-    "//components/strings:components_strings",
-    "//extensions/strings",
-    "//services/strings",
-    "//third_party/blink/public/strings",
-    "//ui/strings:app_locale_settings",
-    "//ui/strings:ui_strings",
-  ]
 }
 
 # Generate cef_api_hash.h.
@@ -1495,9 +1601,37 @@ if (is_mac) {
     ]
   }
 
-  bundle_data("cef_framework_resources") {
+  bundle_data("cef_framework_locales") {
     sources = []
-    public_deps = []
+    foreach(locale, locales_as_mac_outputs) {
+      sources += [ "$root_gen_dir/repack/locales/$locale.pak" ]
+    }
+
+    public_deps = [
+      ":repack_locales_pack",
+    ]
+
+    outputs = [
+      "{{bundle_resources_dir}}/{{source_name_part}}.lproj/locale.pak",
+    ]
+  }
+
+  bundle_data("cef_framework_resources") {
+    sources = [
+      "$root_out_dir/cef.pak",
+      "$root_out_dir/cef_100_percent.pak",
+      "$root_out_dir/cef_200_percent.pak",
+      "$root_out_dir/cef_extensions.pak",
+      "$root_out_dir/devtools_resources.pak",
+    ]
+
+    public_deps = [
+      ":pak",
+      ":pak_100_percent",
+      ":pak_200_percent",
+      ":pak_devtools",
+      ":pak_extensions",
+    ]
 
     if (icu_use_data_file) {
       sources += [ "$root_out_dir/icudtl.dat" ]
@@ -1588,6 +1722,7 @@ if (is_mac) {
 
     deps = [
       ":cef_framework_angle_library",
+      ":cef_framework_locales",
       ":cef_framework_resources",
       ":cef_framework_swiftshader_library",
       ":libcef_static",
@@ -1777,9 +1912,7 @@ if (is_mac) {
 
       sources = invoker.sources
 
-      public_deps = [ ":libcef_dll_wrapper" ]
       deps = [
-        ":cef_make_headers",
         ":libcef_dll_wrapper",
         ":${app_name}_framework_bundle_data",
       ]
@@ -2033,12 +2166,18 @@ if (is_mac) {
     pkg_config("gtk") {
       packages = [
         "gmodule-2.0",
-        "gtk+-3.0",
+        "gtk+-2.0",
         "gthread-2.0",
-        "gtk+-unix-print-3.0",
+        "gtk+-unix-print-2.0",
         "xi",
       ]
     }
+
+    pkg_config("gtkglext") {
+      packages = [
+        "gtkglext-1.0",
+      ]
+    }
   }
 
   if (is_linux) {
@@ -2119,13 +2258,13 @@ if (is_mac) {
       ]
 
       libs = [
-        "GL",
         "X11",
       ]
 
       if (cef_use_gtk) {
         configs += [
           ":gtk",
+          ":gtkglext",
         ]
       }
 
@@ -2218,7 +2357,8 @@ if (is_mac) {
               gypi_paths2.shared_sources_browser +
               gypi_paths2.shared_sources_common +
               gypi_paths2.shared_sources_renderer +
-              gypi_paths2.ceftests_sources_common
+              gypi_paths2.ceftests_sources_common +
+              gypi_paths2.ceftests_sources_views
 
     deps = [
       ":libcef",

CHROMIUM_BUILD_COMPATIBILITY.txt

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

CMakeLists.txt.in

@@ -44,7 +44,8 @@
 #   work but may not have been tested.
 #   Required packages include:
 #     build-essential
-#     libgtk3.0-dev     (required by the cefclient target only)
+#     libgtk2.0-dev     (required by the cefclient target only)
+#     libgtkglext1-dev  (required by the cefclient target only)
 #
 # - MacOS requirements:
 #   Xcode 8 or newer building on MacOS 10.11 (El Capitan) or newer for x86_64.

cef_paths2.gypi

@@ -22,6 +22,7 @@
       'include/base/cef_platform_thread.h',
       'include/base/cef_ref_counted.h',
       'include/base/cef_scoped_ptr.h',
+      'include/base/cef_string16.h',
       'include/base/cef_template_util.h',
       'include/base/cef_thread_checker.h',
       'include/base/cef_trace_event.h',
@@ -127,6 +128,7 @@
       'libcef_dll/base/cef_lock_impl.cc',
       'libcef_dll/base/cef_logging.cc',
       'libcef_dll/base/cef_ref_counted.cc',
+      'libcef_dll/base/cef_string16.cc',
       'libcef_dll/base/cef_thread_checker_impl.cc',
       'libcef_dll/base/cef_weak_ptr.cc',
     ],
@@ -258,8 +260,6 @@
       'tests/cefclient/browser/root_window_create.cc',
       'tests/cefclient/browser/root_window_manager.cc',
       'tests/cefclient/browser/root_window_manager.h',
-      'tests/cefclient/browser/root_window_views.cc',
-      'tests/cefclient/browser/root_window_views.h',
       'tests/cefclient/browser/scheme_test.cc',
       'tests/cefclient/browser/scheme_test.h',
       'tests/cefclient/browser/server_test.cc',
@@ -269,18 +269,10 @@
       'tests/cefclient/browser/test_runner.h',
       'tests/cefclient/browser/urlrequest_test.cc',
       'tests/cefclient/browser/urlrequest_test.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.cc',
       'tests/cefclient/browser/window_test.h',
       'tests/cefclient/browser/window_test_runner.cc',
       'tests/cefclient/browser/window_test_runner.h',
-      'tests/cefclient/browser/window_test_runner_views.cc',
-      'tests/cefclient/browser/window_test_runner_views.h',
     ],
     'cefclient_sources_common': [
       'tests/cefclient/common/client_app_delegates_common.cc',
@@ -353,10 +345,20 @@
       'tests/cefclient/browser/osr_window_win.cc',
       'tests/cefclient/browser/osr_window_win.h',
       'tests/cefclient/browser/resource_util_win_idmap.cc',
+      'tests/cefclient/browser/root_window_views.cc',
+      'tests/cefclient/browser/root_window_views.h',
       'tests/cefclient/browser/root_window_win.cc',
       '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',
+      'tests/cefclient/browser/window_test_runner_views.h',
       'tests/cefclient/browser/window_test_runner_win.cc',
       'tests/cefclient/browser/window_test_runner_win.h',
       'tests/cefclient/cefclient_win.cc',
@@ -409,12 +411,22 @@
       'tests/cefclient/browser/resource_util_linux.cc',
       'tests/cefclient/browser/root_window_gtk.cc',
       'tests/cefclient/browser/root_window_gtk.h',
+      'tests/cefclient/browser/root_window_views.cc',
+      'tests/cefclient/browser/root_window_views.h',
       'tests/cefclient/browser/temp_window_x11.cc',
       'tests/cefclient/browser/temp_window_x11.h',
       'tests/cefclient/browser/util_gtk.cc',
       'tests/cefclient/browser/util_gtk.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',
       'tests/cefclient/browser/window_test_runner_gtk.h',
+      'tests/cefclient/browser/window_test_runner_views.cc',
+      'tests/cefclient/browser/window_test_runner_views.h',
       'tests/cefclient/cefclient_gtk.cc',
     ],
     'cefsimple_sources_common': [
@@ -526,6 +538,12 @@
       'tests/ceftests/v8_unittest.cc',
       'tests/ceftests/values_unittest.cc',
       'tests/ceftests/version_unittest.cc',
+      'tests/ceftests/waitable_event_unittest.cc',
+      'tests/ceftests/webui_unittest.cc',
+      'tests/ceftests/xml_reader_unittest.cc',
+      'tests/ceftests/zip_reader_unittest.cc',
+    ],
+    'ceftests_sources_views': [
       'tests/ceftests/views/button_unittest.cc',
       'tests/ceftests/views/panel_unittest.cc',
       'tests/ceftests/views/scroll_view_unittest.cc',
@@ -533,10 +551,6 @@
       'tests/ceftests/views/test_window_delegate.h',
       'tests/ceftests/views/textfield_unittest.cc',
       'tests/ceftests/views/window_unittest.cc',
-      'tests/ceftests/waitable_event_unittest.cc',
-      'tests/ceftests/webui_unittest.cc',
-      'tests/ceftests/xml_reader_unittest.cc',
-      'tests/ceftests/zip_reader_unittest.cc',
     ],
     'ceftests_sources_win': [
       'tests/ceftests/resource_util_win_idmap.cc',
@@ -561,7 +575,6 @@
       'tests/ceftests/audio_output_unittest.cc',
       'tests/ceftests/client_app_delegates.cc',
       'tests/ceftests/cookie_unittest.cc',
-      'tests/ceftests/cors_unittest.cc',
       'tests/ceftests/dom_unittest.cc',
       'tests/ceftests/frame_unittest.cc',
       'tests/ceftests/message_router_unittest.cc',

cef_repack_locales.gni

@@ -0,0 +1,136 @@
+# Copyright 2016 The Chromium Embedded Framework Authors. Portions copyright
+# 2014 the Chromium Authors. All rights reserved. Use of this source code is
+# governed by a BSD-style license that can be found in the LICENSE file.
+#
+# This is a copy of src/chrome/chrome_repack_locales.gni with the necessary
+# modifications to meet CEF's requirements.
+
+import("//build/config/chrome_build.gni")
+import("//build/config/features.gni")
+import("//build/config/ui.gni")
+import("//tools/grit/repack.gni")
+
+# Arguments:
+#
+#   locale
+#       Internal name of locale. e.g. "pt-BR"
+#
+#   output
+#       Output file name.
+#
+#   visibility
+#       Normal meaning.
+template("_repack_one_locale") {
+  locale = invoker.locale
+
+  repack(target_name) {
+    visibility = invoker.visibility
+
+    # Each input pak file should also have a deps line for completeness.
+    # Add associated .h files in the make_pack_header("strings") target.
+    sources = [
+      "${root_gen_dir}/cef/cef_strings_${locale}.pak",
+      "${root_gen_dir}/chrome/chromium_strings_${locale}.pak",
+      "${root_gen_dir}/chrome/generated_resources_${locale}.pak",
+      "${root_gen_dir}/chrome/locale_settings_${locale}.pak",
+      "${root_gen_dir}/chrome/platform_locale_settings_${locale}.pak",
+      "${root_gen_dir}/components/omnibox/resources/omnibox_resources_${locale}.pak",
+      "${root_gen_dir}/components/strings/components_chromium_strings_${locale}.pak",
+      "${root_gen_dir}/components/strings/components_locale_settings_${locale}.pak",
+      "${root_gen_dir}/components/strings/components_strings_${locale}.pak",
+      "${root_gen_dir}/extensions/strings/extensions_strings_${locale}.pak",
+      "${root_gen_dir}/services/strings/services_strings_${locale}.pak",
+      "${root_gen_dir}/third_party/blink/public/strings/blink_strings_${locale}.pak",
+      "${root_gen_dir}/ui/strings/app_locale_settings_${locale}.pak",
+      "${root_gen_dir}/ui/strings/ui_strings_${locale}.pak",
+    ]
+
+    # Use public_deps so that generated grit headers are discoverable from
+    # the libcef_static target. Grit deps that generate .cc files must be
+    # listed both here and in the libcef_static target.
+    public_deps = [
+      ":cef_strings",
+      "//chrome/app:chromium_strings",
+      "//chrome/app:generated_resources",
+      "//chrome/app/resources:locale_settings",
+      "//chrome/app/resources:platform_locale_settings",
+      "//components/omnibox/resources:omnibox_resources",
+      "//components/strings:components_chromium_strings",
+      "//components/strings:components_locale_settings",
+      "//components/strings:components_strings",
+      "//extensions/strings",
+      "//services/strings",
+      "//third_party/blink/public/strings",
+      "//ui/strings:app_locale_settings",
+      "//ui/strings:ui_strings",
+    ]
+
+    output = invoker.output
+  }
+}
+
+# Creates an action to call the repack_locales script.
+#
+# The GYP version generates the locales in the "gen" directory and then copies
+# it to the root build directory. This isn't easy to express in a GN copy
+# rule since the files on Mac have a complex structure. So we generate the
+# files into the final place and skip the "gen" directory.
+#
+# This template uses GN's looping constructs to avoid the complex call to
+# chrome/tools/build/repack_locales.py which wraps the repack commands in the
+# GYP build.
+#
+# Arguments
+#
+#   input_locales
+#       List of locale names to use as inputs.
+#
+#   output_locales
+#       A list containing the corresponding output names for each of the
+#       input names. Mac uses different names in some cases.
+#
+#   visibility
+template("cef_repack_locales") {
+  # This is the name of the group below that will collect all the invidual
+  # locale targets. External targets will depend on this.
+  group_target_name = target_name
+
+  # GN's subscript is too stupid to do invoker.output_locales[foo] so we need
+  # to make a copy and do output_locales[foo].
+  output_locales = invoker.output_locales
+
+  # Collects all targets the loop generates.
+  locale_targets = []
+
+  # This loop iterates over the input locales and also keeps a counter so it
+  # can simultaneously iterate over the output locales (using GN's very
+  # limited looping capabilities).
+  current_index = 0
+  foreach(input_locale, invoker.input_locales) {
+    output_locale = output_locales[current_index]
+
+    # Compute the name of the target for the current file. Save it for the deps.
+    current_name = "${target_name}_${input_locale}"
+    locale_targets += [ ":$current_name" ]
+
+    _repack_one_locale(current_name) {
+      visibility = [ ":$group_target_name" ]
+      locale = input_locale
+
+      # Compute the output name. Mac uses a different location.
+      if (is_mac || is_ios) {
+        output = "${root_gen_dir}/repack/locales/${output_locale}.pak"
+      } else {
+        output = "${root_out_dir}/locales/${output_locale}.pak"
+      }
+    }
+
+    current_index = current_index + 1
+  }
+
+  # The group that external targets depend on which collects all deps.
+  group(group_target_name) {
+    forward_variables_from(invoker, [ "visibility" ])
+    public_deps = locale_targets
+  }
+}

cmake/cef_variables.cmake.in

@@ -95,7 +95,6 @@ if(OS_LINUX)
     -Wno-unused-parameter           # Don't warn about unused parameters
     -Wno-error=comment              # Don't warn about code in comments
     -Wno-comment                    # Don't warn about code in comments
-    -Wno-deprecated-declarations    # Don't warn about using deprecated methods
     )
   list(APPEND CEF_C_COMPILER_FLAGS
     -std=c99                        # Use the C99 language standard
@@ -229,9 +228,11 @@ if(OS_LINUX)
 
   # List of CEF resource files.
   set(CEF_RESOURCE_FILES
-    chrome_100_percent.pak
-    chrome_200_percent.pak
-    resources.pak
+    cef.pak
+    cef_100_percent.pak
+    cef_200_percent.pak
+    cef_extensions.pak
+    devtools_resources.pak
     icudtl.dat
     locales
     )
@@ -479,9 +480,11 @@ if(OS_WINDOWS)
 
   # List of CEF resource files.
   set(CEF_RESOURCE_FILES
-    chrome_100_percent.pak
-    chrome_200_percent.pak
-    resources.pak
+    cef.pak
+    cef_100_percent.pak
+    cef_200_percent.pak
+    cef_extensions.pak
+    devtools_resources.pak
     icudtl.dat
     locales
     )
@@ -491,9 +494,6 @@ if(OS_WINDOWS)
       PSAPI_VERSION=1   # Required by cef_sandbox.lib
       CEF_USE_SANDBOX   # Used by apps to test if the sandbox is enabled
       )
-    list(APPEND CEF_COMPILER_DEFINES_DEBUG
-      _HAS_ITERATOR_DEBUGGING=0   # Disable iterator debugging
-      )
 
     # Libraries required by cef_sandbox.lib.
     set(CEF_SANDBOX_STANDARD_LIBS

include/base/cef_basictypes.h

@@ -75,6 +75,7 @@ typedef unsigned short uint16;
 #endif
 
 // UTF-16 character type.
+// This should be kept synchronized with base/strings/string16.h
 #ifndef char16
 #if defined(WCHAR_T_IS_UTF16)
 typedef wchar_t char16;

include/base/cef_string16.h

@@ -0,0 +1,223 @@
+// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2013
+// Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CEF_INCLUDE_BASE_CEF_STRING16_H_
+#define CEF_INCLUDE_BASE_CEF_STRING16_H_
+#pragma once
+
+#if defined(BASE_STRINGS_STRING16_H_)
+// Do nothing if the Chromium header has already been included.
+// This can happen in cases where Chromium code is used directly by the
+// client application. When using Chromium code directly always include
+// the Chromium header first to avoid type conflicts.
+#elif defined(USING_CHROMIUM_INCLUDES)
+// When building CEF include the Chromium header directly.
+#include "base/strings/string16.h"
+#else  // !USING_CHROMIUM_INCLUDES
+// The following is substantially similar to the Chromium implementation.
+// If the Chromium implementation diverges the below implementation should be
+// updated to match.
+// WHAT:
+// A version of std::basic_string that provides 2-byte characters even when
+// wchar_t is not implemented as a 2-byte type. You can access this class as
+// string16. We also define char16, which string16 is based upon.
+//
+// WHY:
+// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
+// data. Plenty of existing code operates on strings encoded as UTF-16.
+//
+// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
+// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
+// at run time, because it calls some functions (like wcslen) that come from
+// the system's native C library -- which was built with a 4-byte wchar_t!
+// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
+// entirely improper on those systems where the encoding of wchar_t is defined
+// as UTF-32.
+//
+// Here, we define string16, which is similar to std::wstring but replaces all
+// libc functions with custom, 2-byte-char compatible routines. It is capable
+// of carrying UTF-16-encoded data.
+
+#include <stdio.h>
+#include <string>
+
+#include "include/base/cef_basictypes.h"
+
+#if defined(WCHAR_T_IS_UTF16)
+
+namespace base {
+
+typedef wchar_t char16;
+typedef std::wstring string16;
+typedef std::char_traits<wchar_t> string16_char_traits;
+
+}  // namespace base
+
+#elif defined(WCHAR_T_IS_UTF32)
+
+#include <stdint.h>  // For uint16_t
+
+#include "include/base/cef_macros.h"
+
+namespace cef {
+namespace base {
+
+typedef uint16_t char16;
+
+// char16 versions of the functions required by string16_char_traits; these
+// are based on the wide character functions of similar names ("w" or "wcs"
+// instead of "c16").
+int c16memcmp(const char16* s1, const char16* s2, size_t n);
+size_t c16len(const char16* s);
+const char16* c16memchr(const char16* s, char16 c, size_t n);
+char16* c16memmove(char16* s1, const char16* s2, size_t n);
+char16* c16memcpy(char16* s1, const char16* s2, size_t n);
+char16* c16memset(char16* s, char16 c, size_t n);
+
+struct string16_char_traits {
+  typedef char16 char_type;
+  typedef int int_type;
+
+  // int_type needs to be able to hold each possible value of char_type, and in
+  // addition, the distinct value of eof().
+  COMPILE_ASSERT(sizeof(int_type) > sizeof(char_type), unexpected_type_width);
+
+  typedef std::streamoff off_type;
+  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 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 const char_type* find(const char_type* s,
+                               size_t n,
+                               const char_type& a) {
+    return c16memchr(s, a, n);
+  }
+
+  static char_type* move(char_type* s1, const char_type* s2, int_type n) {
+    return c16memmove(s1, s2, n);
+  }
+
+  static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
+    return c16memcpy(s1, s2, n);
+  }
+
+  static char_type* assign(char_type* s, size_t n, char_type a) {
+    return c16memset(s, a, n);
+  }
+
+  static int_type not_eof(const int_type& c) {
+    return eq_int_type(c, eof()) ? 0 : 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 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); }
+};
+
+typedef std::basic_string<char16, string16_char_traits> string16;
+
+}  // namespace base
+}  // namespace cef
+
+namespace base {
+
+typedef cef::base::char16 char16;
+typedef cef::base::string16 string16;
+
+extern std::ostream& operator<<(std::ostream& out, const string16& str);
+
+// This is required by googletest to print a readable output on test failures.
+extern void PrintTo(const string16& str, std::ostream* out);
+
+}  // namespace base
+
+// The string class will be explicitly instantiated only once, in string16.cc.
+//
+// std::basic_string<> in GNU libstdc++ contains a static data member,
+// _S_empty_rep_storage, to represent empty strings.  When an operation such
+// as assignment or destruction is performed on a string, causing its existing
+// data member to be invalidated, it must not be freed if this static data
+// member is being used.  Otherwise, it counts as an attempt to free static
+// (and not allocated) data, which is a memory error.
+//
+// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
+// as a coalesced symbol, meaning that the linker will combine multiple
+// instances into a single one when generating output.
+//
+// If a string class is used by multiple shared libraries, a problem occurs.
+// Each library will get its own copy of _S_empty_rep_storage.  When strings
+// are passed across a library boundary for alteration or destruction, memory
+// errors will result.  GNU libstdc++ contains a configuration option,
+// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
+// disables the static data member optimization, but it's a good optimization
+// and non-STL code is generally at the mercy of the system's STL
+// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
+// libstdc++ itself or for the libstdc++ installations on the systems we care
+// about, such as Mac OS X and relevant flavors of Linux.
+//
+// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
+//
+// To avoid problems, string classes need to be explicitly instantiated only
+// once, in exactly one library.  All other string users see it via an "extern"
+// declaration.  This is precisely how GNU libstdc++ handles
+// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
+//
+// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
+// in which the linker does not fully coalesce symbols when dead code
+// stripping is enabled.  This bug causes the memory errors described above
+// to occur even when a std::basic_string<> does not cross shared library
+// boundaries, such as in statically-linked executables.
+//
+// TODO(mark): File this bug with Apple and update this note with a bug number.
+
+extern template class std::basic_string<cef::base::char16,
+                                        cef::base::string16_char_traits>;
+
+#endif  // WCHAR_T_IS_UTF32
+
+#endif  // !USING_CHROMIUM_INCLUDES
+
+#endif  // CEF_INCLUDE_BASE_CEF_STRING16_H_

include/capi/cef_browser_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=92c4d38f6895018f72fbafeecb13c47320ef0b1d$
+// $hash=09b6ebd4116e983b4af634f1efa17b326a3fc517$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@@ -139,11 +139,7 @@ typedef struct _cef_browser_t {
   int(CEF_CALLBACK* has_document)(struct _cef_browser_t* self);
 
   ///
-  // Returns the main (top-level) frame for the browser window. In the browser
-  // process this will return a valid object until after
-  // cef_life_span_handler_t::OnBeforeClose is called. In the renderer process
-  // this will return NULL if the main frame is hosted in a different renderer
-  // process (e.g. for cross-origin sub-frames).
+  // Returns the main (top-level) frame for the browser window.
   ///
   struct _cef_frame_t*(CEF_CALLBACK* get_main_frame)(
       struct _cef_browser_t* self);

include/capi/cef_browser_process_handler_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=ade537f836add7fe0b5fd94ceba26d678abb3e43$
+// $hash=f0cd169568e9ea5bcc8bf2aa891691b76c05356d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
@@ -43,6 +43,7 @@
 #include "include/capi/cef_base_capi.h"
 #include "include/capi/cef_client_capi.h"
 #include "include/capi/cef_command_line_capi.h"
+#include "include/capi/cef_print_handler_capi.h"
 #include "include/capi/cef_values_capi.h"
 
 #ifdef __cplusplus
@@ -60,6 +61,25 @@ typedef struct _cef_browser_process_handler_t {
   ///
   cef_base_ref_counted_t base;
 
+  ///
+  // Called on the browser process UI thread to retrieve the list of schemes
+  // that should support cookies. If |include_defaults| is true (1) the default
+  // schemes ("http", "https", "ws" and "wss") will also be supported. Providing
+  // an NULL |schemes| value and setting |include_defaults| to false (0) will
+  // disable all loading and saving of cookies.
+  //
+  // This state will apply to the cef_cookie_manager_t associated with the
+  // global cef_request_context_t. It will also be used as the initial state for
+  // any new cef_request_context_ts created by the client. After creating a new
+  // cef_request_context_t the cef_cookie_manager_t::SetSupportedSchemes
+  // function may be called on the associated cef_cookie_manager_t to futher
+  // override these values.
+  ///
+  void(CEF_CALLBACK* get_cookieable_schemes)(
+      struct _cef_browser_process_handler_t* self,
+      cef_string_list_t schemes,
+      int* include_defaults);
+
   ///
   // Called on the browser process UI thread immediately after the CEF context
   // has been initialized.
@@ -78,6 +98,13 @@ typedef struct _cef_browser_process_handler_t {
       struct _cef_browser_process_handler_t* self,
       struct _cef_command_line_t* command_line);
 
+  ///
+  // Return the handler for printing on Linux. If a print handler is not
+  // provided then printing will not be supported on the Linux platform.
+  ///
+  struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)(
+      struct _cef_browser_process_handler_t* self);
+
   ///
   // Called from any thread when work has been scheduled for the browser process
   // main (UI) thread. This callback is used in combination with CefSettings.

include/capi/cef_client_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=14eca959988209ba8f95037a47192fd50d64f2f1$
+// $hash=4cfcac55d2a1dee466a2a0753f30fb34a78ef3b2$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@@ -53,7 +53,6 @@
 #include "include/capi/cef_keyboard_handler_capi.h"
 #include "include/capi/cef_life_span_handler_capi.h"
 #include "include/capi/cef_load_handler_capi.h"
-#include "include/capi/cef_print_handler_capi.h"
 #include "include/capi/cef_process_message_capi.h"
 #include "include/capi/cef_render_handler_capi.h"
 #include "include/capi/cef_request_handler_capi.h"
@@ -147,13 +146,6 @@ typedef struct _cef_client_t {
   struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)(
       struct _cef_client_t* self);
 
-  ///
-  // Return the handler for printing on Linux. If a print handler is not
-  // provided then printing will not be supported on the Linux platform.
-  ///
-  struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)(
-      struct _cef_client_t* self);
-
   ///
   // Return the handler for off-screen rendering events.
   ///

include/capi/cef_context_menu_handler_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=175779df75a1405fcc5c337a09e6322c556698ba$
+// $hash=bd04d49bcd5d269f237c92163b40435d5588209b$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@@ -294,6 +294,11 @@ typedef struct _cef_context_menu_params_t {
   // items).
   ///
   int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self);
+
+  ///
+  // Returns true (1) if the context menu was invoked from a pepper plugin.
+  ///
+  int(CEF_CALLBACK* is_pepper_menu)(struct _cef_context_menu_params_t* self);
 } cef_context_menu_params_t;
 
 #ifdef __cplusplus

include/capi/cef_cookie_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=b19ef1c8a781f8d59276357609fe64370bb8a107$
+// $hash=20ba58ac3e861344ee738b58433869223c757e24$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
@@ -61,6 +61,21 @@ typedef struct _cef_cookie_manager_t {
   ///
   cef_base_ref_counted_t base;
 
+  ///
+  // Set the schemes supported by this manager. If |include_defaults| is true
+  // (1) the default schemes ("http", "https", "ws" and "wss") will also be
+  // supported. Calling this function with an NULL |schemes| value and
+  // |include_defaults| set to false (0) will disable all loading and saving of
+  // cookies for this manager. If |callback| is non-NULL it will be executed
+  // asnychronously on the UI 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,
+      int include_defaults,
+      struct _cef_completion_callback_t* callback);
+
   ///
   // Visit all cookies on the UI thread. The returned cookies are ordered by
   // longest path, then by earliest creation date. Returns false (0) if cookies

include/capi/cef_media_router_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=79e4e38c732c0cfeef495c8a9726e105054012bb$
+// $hash=3767c7759578cd4abc1c2ecef504e7ed60775abb$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_
@@ -41,7 +41,6 @@
 #pragma once
 
 #include "include/capi/cef_base_capi.h"
-#include "include/capi/cef_callback_capi.h"
 #include "include/capi/cef_registration_capi.h"
 
 #ifdef __cplusplus
@@ -111,14 +110,11 @@ typedef struct _cef_media_router_t {
 } cef_media_router_t;
 
 ///
-// Returns the MediaRouter object associated with the global request context. If
-// |callback| is non-NULL it will be executed asnychronously on the UI thread
-// after the manager's storage has been initialized. Equivalent to calling cef_r
-// equest_context_t::cef_request_context_get_global_context()->get_media_router(
-// ).
+// Returns the MediaRouter object associated with the global request context.
+// Equivalent to calling cef_request_context_t::cef_request_context_get_global_c
+// ontext()->get_media_router().
 ///
-CEF_EXPORT cef_media_router_t* cef_media_router_get_global(
-    struct _cef_completion_callback_t* callback);
+CEF_EXPORT cef_media_router_t* cef_media_router_get_global();
 
 ///
 // Implemented by the client to observe MediaRouter events and registered via

include/capi/cef_print_handler_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=84fc58b3898f25476d9cdd260553390ba5e0b30b$
+// $hash=54ed1e16c5c1d133bcd097350c5f5871228efd4f$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
@@ -148,7 +148,6 @@ typedef struct _cef_print_handler_t {
   ///
   cef_size_t(CEF_CALLBACK* get_pdf_paper_size)(
       struct _cef_print_handler_t* self,
-      struct _cef_browser_t* browser,
       int device_units_per_inch);
 } cef_print_handler_t;
 

include/capi/cef_request_context_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=2e42334fc22050e207e5a0af6fe290a592e4105f$
+// $hash=d5079b6a5146ccd2085c3bbf948925c009d329ed$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
@@ -132,7 +132,7 @@ typedef struct _cef_request_context_t {
 
   ///
   // Returns the cookie manager for this object. If |callback| is non-NULL it
-  // will be executed asnychronously on the UI thread after the manager's
+  // will be executed asnychronously on the IO thread after the manager's
   // storage has been initialized.
   ///
   struct _cef_cookie_manager_t*(CEF_CALLBACK* get_cookie_manager)(
@@ -356,13 +356,10 @@ typedef struct _cef_request_context_t {
       const cef_string_t* extension_id);
 
   ///
-  // Returns the MediaRouter object associated with this context.  If |callback|
-  // is non-NULL it will be executed asnychronously on the UI thread after the
-  // manager's context has been initialized.
+  // Returns the MediaRouter object associated with this context.
   ///
   struct _cef_media_router_t*(CEF_CALLBACK* get_media_router)(
-      struct _cef_request_context_t* self,
-      struct _cef_completion_callback_t* callback);
+      struct _cef_request_context_t* self);
 } cef_request_context_t;
 
 ///

include/capi/cef_web_plugin_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=f74bf4d33914d56d760f1bf5aadcf2651740c711$
+// $hash=d8b5b641cc036a9cd9375442254d558b066ada69$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
@@ -214,7 +214,7 @@ CEF_EXPORT void cef_is_web_plugin_unstable(
 //   D. "x-cdm-interface-versions": Interface API version (e.g. "8").
 //   E. "x-cdm-host-versions": Host API version (e.g. "8").
 //   F. "version": CDM version (e.g. "1.4.8.903").
-//   G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp09,avc1").
+//   G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp9.0,avc1").
 //
 // A through E are used to verify compatibility with the current Chromium
 // version. If the CDM is not compatible the registration will fail and

include/capi/views/cef_browser_view_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=3e4eb9ed3a0cb28ae0459a50f20c8405c7722437$
+// $hash=0fbd582ed5d0231550840ebf3eed2e488ac546d4$
 //
 
 #ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_CAPI_H_
@@ -65,17 +65,6 @@ typedef struct _cef_browser_view_t {
   struct _cef_browser_t*(CEF_CALLBACK* get_browser)(
       struct _cef_browser_view_t* self);
 
-  ///
-  // Returns the Chrome toolbar associated with this BrowserView. Only supported
-  // when using the Chrome runtime. The cef_browser_view_delegate_t::
-  // get_chrome_toolbar_type() function must return a value other than
-  // CEF_CTT_NONE and the toolbar will not be available until after this
-  // BrowserView is added to a cef_window_t and
-  // cef_view_delegate_t::on_window_changed() has been called.
-  ///
-  struct _cef_view_t*(CEF_CALLBACK* get_chrome_toolbar)(
-      struct _cef_browser_view_t* self);
-
   ///
   // Sets whether accelerators registered with cef_window_t::SetAccelerator are
   // triggered before or after the event is sent to the cef_browser_t. If

include/capi/views/cef_browser_view_delegate_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=220a126af3682f716f10b9019e8d1461702aa7c9$
+// $hash=37bbfadf761b3a1996276885d593d27d3fed5f8d$
 //
 
 #ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BROWSER_VIEW_DELEGATE_CAPI_H_
@@ -112,14 +112,6 @@ typedef struct _cef_browser_view_delegate_t {
       struct _cef_browser_view_t* browser_view,
       struct _cef_browser_view_t* popup_browser_view,
       int is_devtools);
-
-  ///
-  // Returns the Chrome toolbar type that will be available via
-  // cef_browser_view_t::get_chrome_toolbar(). See that function for related
-  // documentation.
-  ///
-  cef_chrome_toolbar_type_t(CEF_CALLBACK* get_chrome_toolbar_type)(
-      struct _cef_browser_view_delegate_t* self);
 } cef_browser_view_delegate_t;
 
 #ifdef __cplusplus

include/capi/views/cef_view_delegate_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=a060cb3c53317d758e7f6b4a275288cd08f086e7$
+// $hash=8bd92dd03af4f5cf8c359c45a2d6d013565c2ead$
 //
 
 #ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_VIEW_DELEGATE_CAPI_H_
@@ -114,13 +114,6 @@ typedef struct _cef_view_delegate_t {
                                             int added,
                                             struct _cef_view_t* child);
 
-  ///
-  // Called when |view| is added or removed from the cef_window_t.
-  ///
-  void(CEF_CALLBACK* on_window_changed)(struct _cef_view_delegate_t* self,
-                                        struct _cef_view_t* view,
-                                        int added);
-
   ///
   // Called when |view| gains focus.
   ///

include/cef_api_hash.h

@@ -42,13 +42,13 @@
 // way that may cause binary incompatibility with other builds. The universal
 // hash value will change if any platform is affected whereas the platform hash
 // values will change only if that particular platform is affected.
-#define CEF_API_HASH_UNIVERSAL "d026196d35d8894a836ab3a3d033b84195cdb835"
+#define CEF_API_HASH_UNIVERSAL "89715b43c948313782d2546131f510eab1975844"
 #if defined(OS_WIN)
-#define CEF_API_HASH_PLATFORM "4150bd26e7bf639a9b1f3e5860af8c76eeae8570"
+#define CEF_API_HASH_PLATFORM "80648a2c5a87db1581fdb994b7154ed77d74a3c5"
 #elif defined(OS_MAC)
-#define CEF_API_HASH_PLATFORM "5cc32f88bd134410eff86b21095138b339d572f2"
+#define CEF_API_HASH_PLATFORM "3af393a2bf165edd934c5a59f6e6fce8a4bb579c"
 #elif defined(OS_LINUX)
-#define CEF_API_HASH_PLATFORM "b227b3fdd6142a9d8ff0f2252a71425f15960800"
+#define CEF_API_HASH_PLATFORM "8049cab9a43c1d554ccdd4dd3d5e38ecebce42af"
 #endif
 
 #ifdef __cplusplus

include/cef_browser.h

@@ -142,11 +142,7 @@ class CefBrowser : public virtual CefBaseRefCounted {
   virtual bool HasDocument() = 0;
 
   ///
-  // Returns the main (top-level) frame for the browser window. In the browser
-  // process this will return a valid object until after
-  // CefLifeSpanHandler::OnBeforeClose is called. In the renderer process this
-  // will return NULL if the main frame is hosted in a different renderer
-  // process (e.g. for cross-origin sub-frames).
+  // Returns the main (top-level) frame for the browser window.
   ///
   /*--cef()--*/
   virtual CefRefPtr<CefFrame> GetMainFrame() = 0;

include/cef_browser_process_handler.h

@@ -41,6 +41,7 @@
 #include "include/cef_base.h"
 #include "include/cef_client.h"
 #include "include/cef_command_line.h"
+#include "include/cef_print_handler.h"
 #include "include/cef_values.h"
 
 ///
@@ -50,6 +51,23 @@
 /*--cef(source=client,no_debugct_check)--*/
 class CefBrowserProcessHandler : public virtual CefBaseRefCounted {
  public:
+  ///
+  // Called on the browser process UI thread to retrieve the list of schemes
+  // that should support cookies. If |include_defaults| is true the default
+  // schemes ("http", "https", "ws" and "wss") will also be supported. Providing
+  // an empty |schemes| value and setting |include_defaults| to false will
+  // disable all loading and saving of cookies.
+  //
+  // This state will apply to the CefCookieManager associated with the global
+  // CefRequestContext. It will also be used as the initial state for any new
+  // CefRequestContexts created by the client. After creating a new
+  // CefRequestContext the CefCookieManager::SetSupportedSchemes method may be
+  // called on the associated CefCookieManager to futher override these values.
+  ///
+  /*--cef()--*/
+  virtual void GetCookieableSchemes(std::vector<CefString>& schemes,
+                                    bool& include_defaults) {}
+
   ///
   // Called on the browser process UI thread immediately after the CEF context
   // has been initialized.
@@ -68,6 +86,13 @@ class CefBrowserProcessHandler : public virtual CefBaseRefCounted {
   virtual void OnBeforeChildProcessLaunch(
       CefRefPtr<CefCommandLine> command_line) {}
 
+  ///
+  // Return the handler for printing on Linux. If a print handler is not
+  // provided then printing will not be supported on the Linux platform.
+  ///
+  /*--cef()--*/
+  virtual CefRefPtr<CefPrintHandler> GetPrintHandler() { return nullptr; }
+
   ///
   // Called from any thread when work has been scheduled for the browser process
   // main (UI) thread. This callback is used in combination with CefSettings.

include/cef_client.h

@@ -51,7 +51,6 @@
 #include "include/cef_keyboard_handler.h"
 #include "include/cef_life_span_handler.h"
 #include "include/cef_load_handler.h"
-#include "include/cef_print_handler.h"
 #include "include/cef_process_message.h"
 #include "include/cef_render_handler.h"
 #include "include/cef_request_handler.h"
@@ -140,13 +139,6 @@ class CefClient : public virtual CefBaseRefCounted {
   /*--cef()--*/
   virtual CefRefPtr<CefLoadHandler> GetLoadHandler() { return nullptr; }
 
-  ///
-  // Return the handler for printing on Linux. If a print handler is not
-  // provided then printing will not be supported on the Linux platform.
-  ///
-  /*--cef()--*/
-  virtual CefRefPtr<CefPrintHandler> GetPrintHandler() { return nullptr; }
-
   ///
   // Return the handler for off-screen rendering events.
   ///

include/cef_context_menu_handler.h

@@ -281,6 +281,12 @@ class CefContextMenuParams : public virtual CefBaseRefCounted {
   ///
   /*--cef()--*/
   virtual bool IsCustomMenu() = 0;
+
+  ///
+  // Returns true if the context menu was invoked from a pepper plugin.
+  ///
+  /*--cef()--*/
+  virtual bool IsPepperMenu() = 0;
 };
 
 #endif  // CEF_INCLUDE_CEF_CONTEXT_MENU_HANDLER_H_

include/cef_cookie.h

@@ -64,6 +64,21 @@ class CefCookieManager : public virtual CefBaseRefCounted {
   static CefRefPtr<CefCookieManager> GetGlobalManager(
       CefRefPtr<CefCompletionCallback> callback);
 
+  ///
+  // Set the schemes supported by this manager. If |include_defaults| is true
+  // the default schemes ("http", "https", "ws" and "wss") will also be
+  // supported. Calling this method with an empty |schemes| value and
+  // |include_defaults| set to false will disable all loading and saving of
+  // cookies for this manager. If |callback| is non-NULL it will be executed
+  // asnychronously on the UI thread after the change has been applied. Must be
+  // called before any cookies are accessed.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual void SetSupportedSchemes(
+      const std::vector<CefString>& schemes,
+      bool include_defaults,
+      CefRefPtr<CefCompletionCallback> callback) = 0;
+
   ///
   // Visit all cookies on the UI thread. The returned cookies are ordered by
   // longest path, then by earliest creation date. Returns false if cookies

include/cef_media_router.h

@@ -40,7 +40,6 @@
 
 #include <vector>
 #include "include/cef_base.h"
-#include "include/cef_callback.h"
 #include "include/cef_registration.h"
 
 class CefMediaObserver;
@@ -60,13 +59,11 @@ class CefMediaRouter : public virtual CefBaseRefCounted {
  public:
   ///
   // Returns the MediaRouter object associated with the global request context.
-  // If |callback| is non-NULL it will be executed asnychronously on the UI
-  // thread after the manager's storage has been initialized. Equivalent to
-  // calling CefRequestContext::GetGlobalContext()->GetMediaRouter().
+  // Equivalent to calling
+  // CefRequestContext::GetGlobalContext()->GetMediaRouter().
   ///
-  /*--cef(optional_param=callback)--*/
-  static CefRefPtr<CefMediaRouter> GetGlobalMediaRouter(
-      CefRefPtr<CefCompletionCallback> callback);
+  /*--cef()--*/
+  static CefRefPtr<CefMediaRouter> GetGlobalMediaRouter();
 
   ///
   // Add an observer for MediaRouter events. The observer will remain registered

include/cef_print_handler.h

@@ -133,8 +133,7 @@ class CefPrintHandler : public virtual CefBaseRefCounted {
   // CefBrowserHost::PrintToPDF().
   ///
   /*--cef()--*/
-  virtual CefSize GetPdfPaperSize(CefRefPtr<CefBrowser> browser,
-                                  int device_units_per_inch) {
+  virtual CefSize GetPdfPaperSize(int device_units_per_inch) {
     return CefSize();
   }
 };

include/cef_request_context.h

@@ -146,7 +146,7 @@ class CefRequestContext : public virtual CefBaseRefCounted {
 
   ///
   // Returns the cookie manager for this object. If |callback| is non-NULL it
-  // will be executed asnychronously on the UI thread after the manager's
+  // will be executed asnychronously on the IO thread after the manager's
   // storage has been initialized.
   ///
   /*--cef(optional_param=callback)--*/
@@ -364,13 +364,10 @@ class CefRequestContext : public virtual CefBaseRefCounted {
       const CefString& extension_id) = 0;
 
   ///
-  // Returns the MediaRouter object associated with this context.  If |callback|
-  // is non-NULL it will be executed asnychronously on the UI thread after the
-  // manager's context has been initialized.
+  // Returns the MediaRouter object associated with this context.
   ///
-  /*--cef(optional_param=callback)--*/
-  virtual CefRefPtr<CefMediaRouter> GetMediaRouter(
-      CefRefPtr<CefCompletionCallback> callback) = 0;
+  /*--cef()--*/
+  virtual CefRefPtr<CefMediaRouter> GetMediaRouter() = 0;
 };
 
 #endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_

include/cef_web_plugin.h

@@ -191,7 +191,7 @@ class CefRegisterCdmCallback : public virtual CefBaseRefCounted {
 //   D. "x-cdm-interface-versions": Interface API version (e.g. "8").
 //   E. "x-cdm-host-versions": Host API version (e.g. "8").
 //   F. "version": CDM version (e.g. "1.4.8.903").
-//   G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp09,avc1").
+//   G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp9.0,avc1").
 //
 // A through E are used to verify compatibility with the current Chromium
 // version. If the CDM is not compatible the registration will fail and

include/internal/cef_string_wrappers.h

@@ -34,6 +34,7 @@
 #include <memory.h>
 #include <string>
 
+#include "include/base/cef_string16.h"
 #include "include/internal/cef_string_types.h"
 
 #if defined(USING_CHROMIUM_INCLUDES)
@@ -90,34 +91,27 @@ struct CefStringTraitsWide {
                                                                    : false;
   }
 #if defined(WCHAR_T_IS_UTF32)
-  static inline std::u16string to_string16(const struct_type* s) {
+  static inline base::string16 to_string16(const struct_type* s) {
     cef_string_utf16_t cstr;
     memset(&cstr, 0, sizeof(cstr));
     cef_string_wide_to_utf16(s->str, s->length, &cstr);
-    std::u16string str;
-    if (cstr.length > 0) {
-      str = std::u16string(
-          reinterpret_cast<std::u16string::value_type*>(cstr.str), cstr.length);
-    }
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
     cef_string_utf16_clear(&cstr);
     return str;
   }
-  static inline bool from_string16(const std::u16string& str, struct_type* s) {
-    return cef_string_utf16_to_wide(
-               reinterpret_cast<const char16*>(str.c_str()), str.length(), s)
-               ? true
-               : false;
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_to_wide(str.c_str(), str.length(), s) ? true
+                                                                  : false;
   }
 #else   // WCHAR_T_IS_UTF32
-  static inline std::u16string to_string16(const struct_type* s) {
-    return std::u16string(
-        reinterpret_cast<const std::u16string::value_type*>(s->str), s->length);
+  static inline base::string16 to_string16(const struct_type* s) {
+    return base::string16(s->str, s->length);
   }
-  static inline bool from_string16(const std::u16string& str, struct_type* s) {
-    return cef_string_wide_set(reinterpret_cast<const wchar_t*>(str.c_str()),
-                               str.length(), s, true)
-               ? true
-               : false;
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_wide_set(str.c_str(), str.length(), s, true) ? true
+                                                                   : false;
   }
 #endif  // WCHAR_T_IS_UTF32
 };
@@ -170,23 +164,19 @@ struct CefStringTraitsUTF8 {
   static inline bool from_wstring(const std::wstring& str, struct_type* s) {
     return cef_string_wide_to_utf8(str.c_str(), str.length(), s) ? true : false;
   }
-  static inline std::u16string to_string16(const struct_type* s) {
+  static inline base::string16 to_string16(const struct_type* s) {
     cef_string_utf16_t cstr;
     memset(&cstr, 0, sizeof(cstr));
     cef_string_utf8_to_utf16(s->str, s->length, &cstr);
-    std::u16string str;
-    if (cstr.length > 0) {
-      str = std::u16string(
-          reinterpret_cast<std::u16string::value_type*>(cstr.str), cstr.length);
-    }
+    base::string16 str;
+    if (cstr.length > 0)
+      str = base::string16(cstr.str, cstr.length);
     cef_string_utf16_clear(&cstr);
     return str;
   }
-  static inline bool from_string16(const std::u16string& str, struct_type* s) {
-    return cef_string_utf16_to_utf8(
-               reinterpret_cast<const char16*>(str.c_str()), str.length(), s)
-               ? true
-               : false;
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_to_utf8(str.c_str(), str.length(), s) ? true
+                                                                  : false;
   }
 };
 
@@ -257,15 +247,12 @@ struct CefStringTraitsUTF16 {
                                                                     : false;
   }
 #endif  // WCHAR_T_IS_UTF32
-  static inline std::u16string to_string16(const struct_type* s) {
-    return std::u16string(
-        reinterpret_cast<const std::u16string::value_type*>(s->str), s->length);
+  static inline base::string16 to_string16(const struct_type* s) {
+    return base::string16(s->str, s->length);
   }
-  static inline bool from_string16(const std::u16string& str, struct_type* s) {
-    return cef_string_utf16_set(reinterpret_cast<const char16*>(str.c_str()),
-                                str.length(), s, true)
-               ? true
-               : false;
+  static inline bool from_string16(const base::string16& str, struct_type* s) {
+    return cef_string_utf16_set(str.c_str(), str.length(), s, true) ? true
+                                                                    : false;
   }
 };
 
@@ -342,25 +329,18 @@ class CefStringBase {
       FromWString(std::wstring(src));
   }
 
+#if defined(WCHAR_T_IS_UTF32)
   ///
   // Create a new string from an existing string16. Data will be always
   // copied. Translation will occur if necessary based on the underlying string
   // type.
   ///
-  CefStringBase(const std::u16string& src) : string_(NULL), owner_(false) {
+  CefStringBase(const base::string16& src) : string_(NULL), owner_(false) {
     FromString16(src);
   }
-  CefStringBase(const std::u16string::value_type* src)
-      : string_(NULL), owner_(false) {
-    if (src)
-      FromString16(std::u16string(src));
-  }
-#if defined(WCHAR_T_IS_UTF32)
   CefStringBase(const char16* src) : string_(NULL), owner_(false) {
-    if (src) {
-      FromString16(std::u16string(
-          reinterpret_cast<const std::u16string::value_type*>(src)));
-    }
+    if (src)
+      FromString16(base::string16(src));
   }
 #endif  // WCHAR_T_IS_UTF32
 
@@ -627,9 +607,9 @@ class CefStringBase {
   // Return this string's data as a string16. Translation will occur if
   // necessary based on the underlying string type.
   ///
-  std::u16string ToString16() const {
+  base::string16 ToString16() const {
     if (empty())
-      return std::u16string();
+      return base::string16();
     return traits::to_string16(string_);
   }
 
@@ -638,7 +618,7 @@ class CefStringBase {
   // copied. Translation will occur if necessary based on the underlying string
   // type.
   ///
-  bool FromString16(const std::u16string& str) {
+  bool FromString16(const base::string16& str) {
     if (str.empty()) {
       clear();
       return true;
@@ -690,19 +670,14 @@ class CefStringBase {
     FromWString(std::wstring(str));
     return *this;
   }
-  operator std::u16string() const { return ToString16(); }
-  CefStringBase& operator=(const std::u16string& str) {
+#if defined(WCHAR_T_IS_UTF32)
+  operator base::string16() const { return ToString16(); }
+  CefStringBase& operator=(const base::string16& str) {
     FromString16(str);
     return *this;
   }
-  CefStringBase& operator=(const std::u16string::value_type* str) {
-    FromString16(std::u16string(str));
-    return *this;
-  }
-#if defined(WCHAR_T_IS_UTF32)
   CefStringBase& operator=(const char16* str) {
-    FromString16(std::u16string(
-        reinterpret_cast<const std::u16string::value_type*>(str)));
+    FromString16(base::string16(str));
     return *this;
   }
 #endif  // WCHAR_T_IS_UTF32

include/internal/cef_types.h

@@ -242,9 +242,7 @@ typedef struct _cef_settings_t {
   // in-memory caches are used for storage and no data is persisted to disk.
   // HTML5 databases such as localStorage will only persist across sessions if a
   // cache path is specified. Can be overridden for individual CefRequestContext
-  // instances via the CefRequestContextSettings.cache_path value. When using
-  // the Chrome runtime the "default" profile will be used if |cache_path| and
-  // |root_cache_path| have the same value.
+  // instances via the CefRequestContextSettings.cache_path value.
   ///
   cef_string_t cache_path;
 
@@ -266,8 +264,7 @@ typedef struct _cef_settings_t {
   // directory on Linux, "~/Library/Application Support/CEF/User Data" directory
   // on Mac OS X, "Local Settings\Application Data\CEF\User Data" directory
   // under the user profile directory on Windows). If this value is non-empty
-  // then it must be an absolute path. When using the Chrome runtime this value
-  // will be ignored in favor of the |root_cache_path| value.
+  // then it must be an absolute path.
   ///
   cef_string_t user_data_path;
 
@@ -304,9 +301,9 @@ typedef struct _cef_settings_t {
   // Value that will be inserted as the product portion of the default
   // User-Agent string. If empty the Chromium product version will be used. If
   // |userAgent| is specified this value will be ignored. Also configurable
-  // using the "user-agent-product" command-line switch.
+  // using the "product-version" command-line switch.
   ///
-  cef_string_t user_agent_product;
+  cef_string_t product_version;
 
   ///
   // The locale string that will be passed to WebKit. If empty the default
@@ -345,10 +342,10 @@ typedef struct _cef_settings_t {
 
   ///
   // The fully qualified path for the resources directory. If this value is
-  // empty the *.pak files must be located in the module directory on
-  // Windows/Linux or the app bundle Resources directory on Mac OS X. If this
-  // value is non-empty then it must be an absolute path. Also configurable
-  // using the "resources-dir-path" command-line switch.
+  // empty the cef.pak and/or devtools_resources.pak files must be located in
+  // the module directory on Windows/Linux or the app bundle Resources directory
+  // on Mac OS X. If this value is non-empty then it must be an absolute path.
+  // Also configurable using the "resources-dir-path" command-line switch.
   ///
   cef_string_t resources_dir_path;
 
@@ -422,20 +419,6 @@ typedef struct _cef_settings_t {
   ///
   cef_string_t accept_language_list;
 
-  ///
-  // Comma delimited list of schemes supported by the associated
-  // CefCookieManager. If |cookieable_schemes_exclude_defaults| is false (0) the
-  // default schemes ("http", "https", "ws" and "wss") will also be supported.
-  // Specifying a |cookieable_schemes_list| value and setting
-  // |cookieable_schemes_exclude_defaults| to true (1) will disable all loading
-  // and saving of cookies for this manager. Can be overridden
-  // for individual CefRequestContext instances via the
-  // CefRequestContextSettings.cookieable_schemes_list and
-  // CefRequestContextSettings.cookieable_schemes_exclude_defaults values.
-  ///
-  cef_string_t cookieable_schemes_list;
-  int cookieable_schemes_exclude_defaults;
-
   ///
   // GUID string used for identifying the application. This is passed to the
   // system AV function for scanning downloaded files. By default, the GUID
@@ -504,18 +487,6 @@ typedef struct _cef_request_context_settings_t {
   // ignored if |cache_path| matches the CefSettings.cache_path value.
   ///
   cef_string_t accept_language_list;
-
-  ///
-  // Comma delimited list of schemes supported by the associated
-  // CefCookieManager. If |cookieable_schemes_exclude_defaults| is false (0) the
-  // default schemes ("http", "https", "ws" and "wss") will also be supported.
-  // Specifying a |cookieable_schemes_list| value and setting
-  // |cookieable_schemes_exclude_defaults| to true (1) will disable all loading
-  // and saving of cookies for this manager. These values will be ignored if
-  // |cache_path| matches the CefSettings.cache_path value.
-  ///
-  cef_string_t cookieable_schemes_list;
-  int cookieable_schemes_exclude_defaults;
 } cef_request_context_settings_t;
 
 ///
@@ -614,6 +585,14 @@ typedef struct _cef_browser_settings_t {
   ///
   cef_state_t file_access_from_file_urls;
 
+  ///
+  // Controls whether web security restrictions (same-origin policy) will be
+  // enforced. Disabling this setting is not recommend as it will allow risky
+  // security behavior such as cross-site scripting (XSS). Also configurable
+  // using the "disable-web-security" command-line switch.
+  ///
+  cef_state_t web_security;
+
   ///
   // Controls whether image URLs will be loaded from the network. A cached image
   // will still be rendered if requested. Also configurable using the
@@ -680,7 +659,7 @@ typedef struct _cef_browser_settings_t {
   ///
   // Comma delimited ordered list of language codes without any whitespace that
   // will be used in the "Accept-Language" HTTP header. May be set globally
-  // using the CefSettings.accept_language_list value. If both values are
+  // using the CefBrowserSettings.accept_language_list value. If both values are
   // empty then "en-US,en" will be used.
   ///
   cef_string_t accept_language_list;
@@ -3214,15 +3193,6 @@ typedef enum {
   CEF_TFC_SELECT_ALL,
 } cef_text_field_commands_t;
 
-///
-// Supported Chrome toolbar types.
-///
-typedef enum {
-  CEF_CTT_NONE = 1,
-  CEF_CTT_NORMAL,
-  CEF_CTT_LOCATION,
-} cef_chrome_toolbar_type_t;
-
 #ifdef __cplusplus
 }
 #endif

include/internal/cef_types_wrappers.h

@@ -151,9 +151,10 @@ class CefPoint : public CefStructBase<CefPointTraits> {
  public:
   typedef CefStructBase<CefPointTraits> parent;
 
-  CefPoint() {}
+  CefPoint() : parent() {}
   CefPoint(const cef_point_t& r) : parent(r) {}
-  CefPoint(int x, int y) { Set(x, y); }
+  CefPoint(const CefPoint& r) : parent(r) {}
+  CefPoint(int x, int y) : parent() { Set(x, y); }
 
   bool IsEmpty() const { return x <= 0 && y <= 0; }
   void Set(int x_val, int y_val) { x = x_val, y = y_val; }
@@ -187,9 +188,12 @@ class CefRect : public CefStructBase<CefRectTraits> {
  public:
   typedef CefStructBase<CefRectTraits> parent;
 
-  CefRect() {}
+  CefRect() : parent() {}
   CefRect(const cef_rect_t& r) : parent(r) {}
-  CefRect(int x, int y, int width, int height) { Set(x, y, width, height); }
+  CefRect(const CefRect& r) : parent(r) {}
+  CefRect(int x, int y, int width, int height) : parent() {
+    Set(x, y, width, height);
+  }
 
   bool IsEmpty() const { return width <= 0 || height <= 0; }
   void Set(int x_val, int y_val, int width_val, int height_val) {
@@ -236,9 +240,10 @@ class CefSize : public CefStructBase<CefSizeTraits> {
  public:
   typedef CefStructBase<CefSizeTraits> parent;
 
-  CefSize() {}
+  CefSize() : parent() {}
   CefSize(const cef_size_t& r) : parent(r) {}
-  CefSize(int width, int height) { Set(width, height); }
+  CefSize(const CefSize& r) : parent(r) {}
+  CefSize(int width, int height) : parent() { Set(width, height); }
 
   bool IsEmpty() const { return width <= 0 || height <= 0; }
   void Set(int width_val, int height_val) {
@@ -274,9 +279,10 @@ class CefRange : public CefStructBase<CefRangeTraits> {
  public:
   typedef CefStructBase<CefRangeTraits> parent;
 
-  CefRange() {}
+  CefRange() : parent() {}
   CefRange(const cef_range_t& r) : parent(r) {}
-  CefRange(int from, int to) { Set(from, to); }
+  CefRange(const CefRange& r) : parent(r) {}
+  CefRange(int from, int to) : parent() { Set(from, to); }
 
   void Set(int from_val, int to_val) { from = from_val, to = to_val; }
 };
@@ -309,9 +315,10 @@ class CefInsets : public CefStructBase<CefInsetsTraits> {
  public:
   typedef CefStructBase<CefInsetsTraits> parent;
 
-  CefInsets() {}
+  CefInsets() : parent() {}
   CefInsets(const cef_insets_t& r) : parent(r) {}
-  CefInsets(int top, int left, int bottom, int right) {
+  CefInsets(const CefInsets& r) : parent(r) {}
+  CefInsets(int top, int left, int bottom, int right) : parent() {
     Set(top, left, bottom, right);
   }
 
@@ -349,9 +356,10 @@ class CefDraggableRegion : public CefStructBase<CefDraggableRegionTraits> {
  public:
   typedef CefStructBase<CefDraggableRegionTraits> parent;
 
-  CefDraggableRegion() {}
+  CefDraggableRegion() : parent() {}
   CefDraggableRegion(const cef_draggable_region_t& r) : parent(r) {}
-  CefDraggableRegion(const CefRect& bounds, bool draggable) {
+  CefDraggableRegion(const CefDraggableRegion& r) : parent(r) {}
+  CefDraggableRegion(const CefRect& bounds, bool draggable) : parent() {
     Set(bounds, draggable);
   }
 
@@ -397,14 +405,16 @@ class CefScreenInfo : public CefStructBase<CefScreenInfoTraits> {
  public:
   typedef CefStructBase<CefScreenInfoTraits> parent;
 
-  CefScreenInfo() {}
+  CefScreenInfo() : parent() {}
   CefScreenInfo(const cef_screen_info_t& r) : parent(r) {}
+  CefScreenInfo(const CefScreenInfo& r) : parent(r) {}
   CefScreenInfo(float device_scale_factor,
                 int depth,
                 int depth_per_component,
                 bool is_monochrome,
                 const CefRect& rect,
-                const CefRect& available_rect) {
+                const CefRect& available_rect)
+      : parent() {
     Set(device_scale_factor, depth, depth_per_component, is_monochrome, rect,
         available_rect);
   }
@@ -538,14 +548,13 @@ struct CefSettingsTraits {
     cef_string_clear(&s->root_cache_path);
     cef_string_clear(&s->user_data_path);
     cef_string_clear(&s->user_agent);
-    cef_string_clear(&s->user_agent_product);
+    cef_string_clear(&s->product_version);
     cef_string_clear(&s->locale);
     cef_string_clear(&s->log_file);
     cef_string_clear(&s->javascript_flags);
     cef_string_clear(&s->resources_dir_path);
     cef_string_clear(&s->locales_dir_path);
     cef_string_clear(&s->accept_language_list);
-    cef_string_clear(&s->cookieable_schemes_list);
     cef_string_clear(&s->application_client_id_for_file_scanning);
   }
 
@@ -577,8 +586,8 @@ struct CefSettingsTraits {
 
     cef_string_set(src->user_agent.str, src->user_agent.length,
                    &target->user_agent, copy);
-    cef_string_set(src->user_agent_product.str, src->user_agent_product.length,
-                   &target->user_agent_product, copy);
+    cef_string_set(src->product_version.str, src->product_version.length,
+                   &target->product_version, copy);
     cef_string_set(src->locale.str, src->locale.length, &target->locale, copy);
 
     cef_string_set(src->log_file.str, src->log_file.length, &target->log_file,
@@ -600,13 +609,6 @@ struct CefSettingsTraits {
     cef_string_set(src->accept_language_list.str,
                    src->accept_language_list.length,
                    &target->accept_language_list, copy);
-
-    cef_string_set(src->cookieable_schemes_list.str,
-                   src->cookieable_schemes_list.length,
-                   &target->cookieable_schemes_list, copy);
-    target->cookieable_schemes_exclude_defaults =
-        src->cookieable_schemes_exclude_defaults;
-
     cef_string_set(src->application_client_id_for_file_scanning.str,
                    src->application_client_id_for_file_scanning.length,
                    &target->application_client_id_for_file_scanning, copy);
@@ -626,7 +628,6 @@ struct CefRequestContextSettingsTraits {
   static inline void clear(struct_type* s) {
     cef_string_clear(&s->cache_path);
     cef_string_clear(&s->accept_language_list);
-    cef_string_clear(&s->cookieable_schemes_list);
   }
 
   static inline void set(const struct_type* src,
@@ -640,12 +641,6 @@ struct CefRequestContextSettingsTraits {
     cef_string_set(src->accept_language_list.str,
                    src->accept_language_list.length,
                    &target->accept_language_list, copy);
-
-    cef_string_set(src->cookieable_schemes_list.str,
-                   src->cookieable_schemes_list.length,
-                   &target->cookieable_schemes_list, copy);
-    target->cookieable_schemes_exclude_defaults =
-        src->cookieable_schemes_exclude_defaults;
   }
 };
 
@@ -710,6 +705,7 @@ struct CefBrowserSettingsTraits {
     target->universal_access_from_file_urls =
         src->universal_access_from_file_urls;
     target->file_access_from_file_urls = src->file_access_from_file_urls;
+    target->web_security = src->web_security;
     target->image_loading = src->image_loading;
     target->image_shrink_standalone_to_fit =
         src->image_shrink_standalone_to_fit;
@@ -796,10 +792,11 @@ class CefTime : public CefStructBase<CefTimeTraits> {
  public:
   typedef CefStructBase<CefTimeTraits> parent;
 
-  CefTime() {}
+  CefTime() : parent() {}
   CefTime(const cef_time_t& r) : parent(r) {}
-  explicit CefTime(time_t r) { SetTimeT(r); }
-  explicit CefTime(double r) { SetDoubleT(r); }
+  CefTime(const CefTime& r) : parent(r) {}
+  explicit CefTime(time_t r) : parent() { SetTimeT(r); }
+  explicit CefTime(double r) : parent() { SetDoubleT(r); }
 
   // Converts to/from time_t.
   void SetTimeT(time_t r) { cef_time_from_timet(r, this); }

include/views/cef_browser_view.h

@@ -80,17 +80,6 @@ class CefBrowserView : public CefView {
   /*--cef()--*/
   virtual CefRefPtr<CefBrowser> GetBrowser() = 0;
 
-  ///
-  // Returns the Chrome toolbar associated with this BrowserView. Only supported
-  // when using the Chrome runtime. The CefBrowserViewDelegate::
-  // GetChromeToolbarType() method must return a value other than
-  // CEF_CTT_NONE and the toolbar will not be available until after this
-  // BrowserView is added to a CefWindow and CefViewDelegate::OnWindowChanged()
-  // has been called.
-  ///
-  /*--cef()--*/
-  virtual CefRefPtr<CefView> GetChromeToolbar() = 0;
-
   ///
   // Sets whether accelerators registered with CefWindow::SetAccelerator are
   // triggered before or after the event is sent to the CefBrowser. If

include/views/cef_browser_view_delegate.h

@@ -52,8 +52,6 @@ class CefBrowserView;
 /*--cef(source=client)--*/
 class CefBrowserViewDelegate : public CefViewDelegate {
  public:
-  typedef cef_chrome_toolbar_type_t ChromeToolbarType;
-
   ///
   // Called when |browser| associated with |browser_view| is created. This
   // method will be called after CefLifeSpanHandler::OnAfterCreated() is called
@@ -106,14 +104,6 @@ class CefBrowserViewDelegate : public CefViewDelegate {
       bool is_devtools) {
     return false;
   }
-
-  ///
-  // Returns the Chrome toolbar type that will be available via
-  // CefBrowserView::GetChromeToolbar(). See that method for related
-  // documentation.
-  ///
-  /*--cef(default_retval=CEF_CTT_NONE)--*/
-  virtual ChromeToolbarType GetChromeToolbarType() { return CEF_CTT_NONE; }
 };
 
 #endif  // CEF_INCLUDE_VIEWS_CEF_BROWSER_VIEW_DELEGATE_H_

include/views/cef_view_delegate.h

@@ -105,12 +105,6 @@ class CefViewDelegate : public virtual CefBaseRefCounted {
                                   bool added,
                                   CefRefPtr<CefView> child) {}
 
-  ///
-  // Called when |view| is added or removed from the CefWindow.
-  ///
-  /*--cef(optional_param=window)--*/
-  virtual void OnWindowChanged(CefRefPtr<CefView> view, bool added) {}
-
   ///
   // Called when |view| gains focus.
   ///

libcef/browser/alloy/alloy_browser_context.cc

@@ -113,18 +113,6 @@ AlloyBrowserContext::~AlloyBrowserContext() {
   }
 }
 
-bool AlloyBrowserContext::IsInitialized() const {
-  CEF_REQUIRE_UIT();
-  return !!key_;
-}
-
-void AlloyBrowserContext::StoreOrTriggerInitCallback(
-    base::OnceClosure callback) {
-  CEF_REQUIRE_UIT();
-  // Initialization is always synchronous.
-  std::move(callback).Run();
-}
-
 void AlloyBrowserContext::Initialize() {
   CefBrowserContext::Initialize();
 
@@ -309,6 +297,15 @@ AlloyBrowserContext::GetClientHintsControllerDelegate() {
   return nullptr;
 }
 
+void AlloyBrowserContext::SetCorsOriginAccessListForOrigin(
+    const url::Origin& source_origin,
+    std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
+    std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
+    base::OnceClosure closure) {
+  // This method is called for Extension support.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, std::move(closure));
+}
+
 ChromeZoomLevelPrefs* AlloyBrowserContext::GetZoomLevelPrefs() {
   return static_cast<ChromeZoomLevelPrefs*>(
       GetStoragePartition(this, nullptr)->GetZoomLevelDelegate());
@@ -440,11 +437,6 @@ AlloyBrowserContext::GetProfilePolicyConnector() const {
   return nullptr;
 }
 
-bool AlloyBrowserContext::IsNewProfile() const {
-  NOTREACHED();
-  return false;
-}
-
 void AlloyBrowserContext::RebuildTable(
     const scoped_refptr<URLEnumerator>& enumerator) {
   // Called when visited links will not or cannot be loaded from disk.

libcef/browser/alloy/alloy_browser_context.h

@@ -42,8 +42,6 @@ class AlloyBrowserContext : public ChromeProfileAlloy,
   // CefBrowserContext overrides.
   content::BrowserContext* AsBrowserContext() override { return this; }
   Profile* AsProfile() override { return this; }
-  bool IsInitialized() const override;
-  void StoreOrTriggerInitCallback(base::OnceClosure callback) override;
   void Initialize() override;
   void Shutdown() override;
   void RemoveCefRequestContext(CefRequestContextImpl* context) override;
@@ -60,6 +58,11 @@ class AlloyBrowserContext : public ChromeProfileAlloy,
   content::ResourceContext* GetResourceContext() override;
   content::ClientHintsControllerDelegate* GetClientHintsControllerDelegate()
       override;
+  void SetCorsOriginAccessListForOrigin(
+      const url::Origin& source_origin,
+      std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
+      std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
+      base::OnceClosure closure) override;
   base::FilePath GetPath() override;
   base::FilePath GetPath() const override;
   std::unique_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
@@ -91,7 +94,6 @@ class AlloyBrowserContext : public ChromeProfileAlloy,
   policy::ProfilePolicyConnector* GetProfilePolicyConnector() override;
   const policy::ProfilePolicyConnector* GetProfilePolicyConnector()
       const override;
-  bool IsNewProfile() const override;
 
   // Values checked in ProfileNetworkContextService::CreateNetworkContextParams
   // when creating the NetworkContext.

libcef/browser/alloy/alloy_browser_host_impl.cc

@@ -24,7 +24,6 @@
 #include "libcef/common/cef_messages.h"
 #include "libcef/common/cef_switches.h"
 #include "libcef/common/drag_data_impl.h"
-#include "libcef/common/net/url_util.h"
 #include "libcef/common/request_impl.h"
 #include "libcef/common/values_impl.h"
 #include "libcef/features/runtime_checks.h"
@@ -176,13 +175,12 @@ CefRefPtr<AlloyBrowserHostImpl> AlloyBrowserHostImpl::Create(
   if (!browser)
     return nullptr;
 
-  GURL url = url_util::MakeGURL(create_params.url, /*fixup=*/true);
-
   if (create_params.extension) {
     platform_delegate_ptr->CreateExtensionHost(
-        create_params.extension, url, create_params.extension_host_type);
-  } else if (!url.is_empty()) {
-    content::OpenURLParams params(url, content::Referrer(),
+        create_params.extension, create_params.url,
+        create_params.extension_host_type);
+  } else if (!create_params.url.is_empty()) {
+    content::OpenURLParams params(create_params.url, content::Referrer(),
                                   WindowOpenDisposition::CURRENT_TAB,
                                   CefFrameHostImpl::kPageTransitionExplicit,
                                   /*is_renderer_initiated=*/false);
@@ -380,7 +378,7 @@ void AlloyBrowserHostImpl::SetFocusInternal(bool focus) {
 }
 
 CefWindowHandle AlloyBrowserHostImpl::GetWindowHandle() {
-  if (is_views_hosted_ && CEF_CURRENTLY_ON_UIT()) {
+  if (IsViewsHosted() && CEF_CURRENTLY_ON_UIT()) {
     // Always return the most up-to-date window handle for a views-hosted
     // browser since it may change if the view is re-parented.
     if (platform_delegate_)
@@ -393,6 +391,10 @@ CefWindowHandle AlloyBrowserHostImpl::GetOpenerWindowHandle() {
   return opener_;
 }
 
+bool AlloyBrowserHostImpl::HasView() {
+  return IsViewsHosted();
+}
+
 double AlloyBrowserHostImpl::GetZoomLevel() {
   // Verify that this method is being called on the UI thread.
   if (!CEF_CURRENTLY_ON_UIT()) {
@@ -530,6 +532,82 @@ bool AlloyBrowserHostImpl::HasDevTools() {
   return devtools_manager_->HasDevTools();
 }
 
+bool AlloyBrowserHostImpl::SendDevToolsMessage(const void* message,
+                                               size_t message_size) {
+  if (!message || message_size == 0)
+    return false;
+
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    std::string message_str(static_cast<const char*>(message), message_size);
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(
+            [](CefRefPtr<AlloyBrowserHostImpl> self, std::string message_str) {
+              self->SendDevToolsMessage(message_str.data(), message_str.size());
+            },
+            CefRefPtr<AlloyBrowserHostImpl>(this), std::move(message_str)));
+    return false;
+  }
+
+  if (!EnsureDevToolsManager())
+    return false;
+  return devtools_manager_->SendDevToolsMessage(message, message_size);
+}
+
+int AlloyBrowserHostImpl::ExecuteDevToolsMethod(
+    int message_id,
+    const CefString& method,
+    CefRefPtr<CefDictionaryValue> params) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(
+            base::IgnoreResult(&AlloyBrowserHostImpl::ExecuteDevToolsMethod),
+            this, message_id, method, params));
+    return 0;
+  }
+
+  if (!EnsureDevToolsManager())
+    return 0;
+  return devtools_manager_->ExecuteDevToolsMethod(message_id, method, params);
+}
+
+CefRefPtr<CefRegistration> AlloyBrowserHostImpl::AddDevToolsMessageObserver(
+    CefRefPtr<CefDevToolsMessageObserver> observer) {
+  if (!observer)
+    return nullptr;
+  auto registration = CefDevToolsManager::CreateRegistration(observer);
+  InitializeDevToolsRegistrationOnUIThread(registration);
+  return registration.get();
+}
+
+bool AlloyBrowserHostImpl::EnsureDevToolsManager() {
+  CEF_REQUIRE_UIT();
+  if (!web_contents())
+    return false;
+
+  if (!devtools_manager_) {
+    devtools_manager_.reset(new CefDevToolsManager(this));
+  }
+  return true;
+}
+
+void AlloyBrowserHostImpl::InitializeDevToolsRegistrationOnUIThread(
+    CefRefPtr<CefRegistration> registration) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(
+            &AlloyBrowserHostImpl::InitializeDevToolsRegistrationOnUIThread,
+            this, registration));
+    return;
+  }
+
+  if (!EnsureDevToolsManager())
+    return;
+  devtools_manager_->InitializeRegistrationOnUIThread(registration);
+}
+
 void AlloyBrowserHostImpl::SetAccessibilityState(
     cef_state_t accessibility_state) {
   if (!CEF_CURRENTLY_ON_UIT()) {
@@ -725,6 +803,10 @@ bool AlloyBrowserHostImpl::IsWindowless() const {
   return is_windowless_;
 }
 
+bool AlloyBrowserHostImpl::IsViewsHosted() const {
+  return is_views_hosted_;
+}
+
 bool AlloyBrowserHostImpl::IsPictureInPictureSupported() const {
   // Not currently supported with OSR.
   return !IsWindowless();
@@ -783,9 +865,27 @@ void AlloyBrowserHostImpl::DestroyBrowser() {
   recently_audible_timer_.Stop();
   audio_capturer_.reset(nullptr);
 
+  devtools_manager_.reset(nullptr);
+
   CefBrowserHostBase::DestroyBrowser();
 }
 
+#if defined(USE_AURA)
+views::Widget* AlloyBrowserHostImpl::GetWindowWidget() const {
+  CEF_REQUIRE_UIT();
+  if (!platform_delegate_)
+    return nullptr;
+  return platform_delegate_->GetWindowWidget();
+}
+
+CefRefPtr<CefBrowserView> AlloyBrowserHostImpl::GetBrowserView() const {
+  CEF_REQUIRE_UIT();
+  if (IsViewsHosted() && platform_delegate_)
+    return platform_delegate_->GetBrowserView();
+  return nullptr;
+}
+#endif
+
 void AlloyBrowserHostImpl::CancelContextMenu() {
   CEF_REQUIRE_UIT();
   if (menu_manager_)
@@ -812,6 +912,12 @@ bool AlloyBrowserHostImpl::MaybeAllowNavigation(
   return true;
 }
 
+SkColor AlloyBrowserHostImpl::GetBackgroundColor() const {
+  // Don't use |platform_delegate_| because it's not thread-safe.
+  return CefContext::Get()->GetBackgroundColor(
+      &settings_, is_windowless_ ? STATE_ENABLED : STATE_DISABLED);
+}
+
 extensions::ExtensionHost* AlloyBrowserHostImpl::GetExtensionHost() const {
   CEF_REQUIRE_UIT();
   DCHECK(platform_delegate_);
@@ -1169,11 +1275,6 @@ void AlloyBrowserHostImpl::CloseContents(content::WebContents* source) {
       // destroyed.
       CefRefPtr<AlloyBrowserHostImpl> browser(this);
 
-      if (source) {
-        // Try to fast shutdown the associated process.
-        source->GetMainFrame()->GetProcess()->FastShutdownIfPossible(1, false);
-      }
-
       // No window exists. Destroy the browser immediately. Don't call other
       // browser methods after calling DestroyBrowser().
       DestroyBrowser();
@@ -1191,9 +1292,9 @@ void AlloyBrowserHostImpl::UpdateTargetURL(content::WebContents* source,
 bool AlloyBrowserHostImpl::DidAddMessageToConsole(
     content::WebContents* source,
     blink::mojom::ConsoleMessageLevel level,
-    const std::u16string& message,
+    const base::string16& message,
     int32_t line_no,
-    const std::u16string& source_id) {
+    const base::string16& source_id) {
   return contents_delegate_->DidAddMessageToConsole(source, level, message,
                                                     line_no, source_id);
 }
@@ -1472,13 +1573,11 @@ void AlloyBrowserHostImpl::ExitPictureInPicture() {
 // content::WebContentsObserver methods.
 // -----------------------------------------------------------------------------
 
-void AlloyBrowserHostImpl::RenderFrameCreated(
-    content::RenderFrameHost* render_frame_host) {
-  if (render_frame_host->GetParent() == nullptr) {
-    auto render_view_host = render_frame_host->GetRenderViewHost();
-    new CefWidgetHostInterceptor(this, render_view_host);
-    platform_delegate_->RenderViewCreated(render_view_host);
-  }
+void AlloyBrowserHostImpl::RenderViewCreated(
+    content::RenderViewHost* render_view_host) {
+  new CefWidgetHostInterceptor(this, render_view_host);
+
+  platform_delegate_->RenderViewCreated(render_view_host);
 }
 
 void AlloyBrowserHostImpl::RenderViewReady() {
@@ -1585,10 +1684,11 @@ AlloyBrowserHostImpl::AlloyBrowserHostImpl(
       content::WebContentsObserver(web_contents),
       opener_(kNullWindowHandle),
       is_windowless_(platform_delegate_->IsWindowless()),
+      is_views_hosted_(platform_delegate_->IsViewsHosted()),
       extension_(extension) {
   contents_delegate_->ObserveWebContents(web_contents);
 
-  if (opener.get() && !is_views_hosted_) {
+  if (opener.get() && !platform_delegate_->IsViewsHosted()) {
     // GetOpenerWindowHandle() only returns a value for non-views-hosted
     // popup browsers.
     opener_ = opener->GetWindowHandle();
@@ -1597,8 +1697,8 @@ AlloyBrowserHostImpl::AlloyBrowserHostImpl(
   // Associate the platform delegate with this browser.
   platform_delegate_->BrowserCreated(this);
 
-  // Make sure RenderFrameCreated is called at least one time.
-  RenderFrameCreated(web_contents->GetMainFrame());
+  // Make sure RenderViewCreated is called at least one time.
+  RenderViewCreated(web_contents->GetRenderViewHost());
 }
 
 bool AlloyBrowserHostImpl::CreateHostWindow() {
@@ -1607,7 +1707,7 @@ bool AlloyBrowserHostImpl::CreateHostWindow() {
   bool success = true;
   if (!IsWindowless())
     success = platform_delegate_->CreateHostWindow();
-  if (success && !is_views_hosted_)
+  if (success && !IsViewsHosted())
     host_window_handle_ = platform_delegate_->GetHostWindowHandle();
   return success;
 }
@@ -1632,8 +1732,7 @@ void AlloyBrowserHostImpl::StartDragging(
   }
 }
 
-void AlloyBrowserHostImpl::UpdateDragCursor(
-    ui::mojom::DragOperation operation) {
+void AlloyBrowserHostImpl::UpdateDragCursor(blink::DragOperation operation) {
   if (platform_delegate_)
     platform_delegate_->UpdateDragCursor(operation);
 }

libcef/browser/alloy/alloy_browser_host_impl.h

@@ -22,14 +22,16 @@
 #include "libcef/browser/menu_manager.h"
 #include "libcef/browser/request_context_impl.h"
 
+#include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
-#include "extensions/common/mojom/view_type.mojom-forward.h"
+#include "extensions/common/view_type.h"
 
 class CefAudioCapturer;
 class CefBrowserInfo;
+class CefDevToolsManager;
 class SiteInstance;
 
 // CefBrowser implementation for the alloy runtime. Method calls are delegated
@@ -86,6 +88,7 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   void SetFocus(bool focus) override;
   CefWindowHandle GetWindowHandle() override;
   CefWindowHandle GetOpenerWindowHandle() override;
+  bool HasView() override;
   double GetZoomLevel() override;
   void SetZoomLevel(double zoomLevel) override;
   void RunFileDialog(FileDialogMode mode,
@@ -110,6 +113,12 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
                     const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
+  bool SendDevToolsMessage(const void* message, size_t message_size) override;
+  int ExecuteDevToolsMethod(int message_id,
+                            const CefString& method,
+                            CefRefPtr<CefDictionaryValue> params) override;
+  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
+      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   bool IsWindowRenderingDisabled() override;
   void WasResized() override;
   void WasHidden(bool hidden) override;
@@ -150,13 +159,16 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   bool IsBackgroundHost() override;
 
   // Returns true if windowless rendering is enabled.
-  bool IsWindowless() const override;
+  bool IsWindowless() const;
+
+  // Returns true if this browser is views-hosted.
+  bool IsViewsHosted() const;
 
   // Returns true if this browser supports picture-in-picture.
   bool IsPictureInPictureSupported() const;
 
   // Called when the OS window hosting the browser is destroyed.
-  void WindowDestroyed() override;
+  void WindowDestroyed();
 
   // Destroy the browser members. This method should only be called after the
   // native browser window is not longer processing messages.
@@ -165,6 +177,16 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   // Cancel display of the context menu, if any.
   void CancelContextMenu();
 
+#if defined(USE_AURA)
+  // Returns the Widget owner for the browser window. Only used with windowed
+  // rendering.
+  views::Widget* GetWindowWidget() const;
+
+  // Returns the BrowserView associated with this browser. Only used with views-
+  // based browsers.
+  CefRefPtr<CefBrowserView> GetBrowserView() const;
+#endif
+
   bool MaybeAllowNavigation(content::RenderFrameHost* opener,
                             bool is_guest_view,
                             const content::OpenURLParams& params) override;
@@ -179,7 +201,10 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
                      const gfx::Vector2d& image_offset,
                      const blink::mojom::DragEventSourceInfo& event_info,
                      content::RenderWidgetHostImpl* source_rwh);
-  void UpdateDragCursor(ui::mojom::DragOperation operation);
+  void UpdateDragCursor(blink::DragOperation operation);
+
+  // Thread safe accessors.
+  SkColor GetBackgroundColor() const;
 
   // Accessors that must be called on the UI thread.
   extensions::ExtensionHost* GetExtensionHost() const;
@@ -221,9 +246,9 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
   bool DidAddMessageToConsole(content::WebContents* source,
                               blink::mojom::ConsoleMessageLevel log_level,
-                              const std::u16string& message,
+                              const base::string16& message,
                               int32_t line_no,
-                              const std::u16string& source_id) override;
+                              const base::string16& source_id) override;
   void BeforeUnloadFired(content::WebContents* source,
                          bool proceed,
                          bool* proceed_to_fire_unload) override;
@@ -295,7 +320,7 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
 
   // content::WebContentsObserver methods.
   using content::WebContentsObserver::BeforeUnloadFired;
-  void RenderFrameCreated(content::RenderFrameHost* render_frame_host) override;
+  void RenderViewCreated(content::RenderViewHost* render_view_host) override;
   void RenderViewReady() override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
@@ -341,10 +366,15 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   void StartAudioCapturer();
   void OnRecentlyAudibleTimerFired();
 
+  bool EnsureDevToolsManager();
+  void InitializeDevToolsRegistrationOnUIThread(
+      CefRefPtr<CefRegistration> registration);
+
   void SetFocusInternal(bool focus);
 
   CefWindowHandle opener_;
   const bool is_windowless_;
+  const bool is_views_hosted_;
   CefWindowHandle host_window_handle_ = kNullWindowHandle;
   CefRefPtr<CefExtension> extension_;
   bool is_background_host_ = false;
@@ -366,6 +396,9 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   // Used for creating and managing context menus.
   std::unique_ptr<CefMenuManager> menu_manager_;
 
+  // Used for creating and managing DevTools instances.
+  std::unique_ptr<CefDevToolsManager> devtools_manager_;
+
   // Used for capturing audio for CefAudioHandler.
   std::unique_ptr<CefAudioCapturer> audio_capturer_;
 

libcef/browser/alloy/alloy_browser_main.cc

@@ -16,6 +16,7 @@
 #include "libcef/browser/extensions/extensions_browser_client.h"
 #include "libcef/browser/net/chrome_scheme_handler.h"
 #include "libcef/browser/printing/constrained_window_views_client.h"
+#include "libcef/browser/printing/printing_message_filter.h"
 #include "libcef/browser/thread_util.h"
 #include "libcef/common/app_manager.h"
 #include "libcef/common/extensions/extensions_client.h"
@@ -25,7 +26,6 @@
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
-#include "base/task/thread_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/media/router/chrome_media_router_factory.h"
 #include "chrome/browser/net/system_network_context_manager.h"
@@ -53,6 +53,7 @@
 #include "chrome/browser/chrome_browser_main_win.h"
 #include "chrome/browser/win/parental_controls.h"
 #include "components/os_crypt/os_crypt.h"
+#include "ui/base/cursor/cursor_loader_win.h"
 #endif
 #endif  // defined(USE_AURA)
 
@@ -97,6 +98,11 @@ void AlloyBrowserMainParts::ToolkitInitialized() {
   CHECK(aura::Env::GetInstance());
 
   wm_state_.reset(new wm::WMState);
+
+#if defined(OS_WIN)
+  ui::CursorLoaderWin::SetCursorResourceModule(
+      CefAppManager::Get()->GetResourceDllName());
+#endif
 #endif  // defined(USE_AURA)
 
 #if defined(TOOLKIT_VIEWS)
@@ -153,7 +159,7 @@ int AlloyBrowserMainParts::PreCreateThreads() {
   return 0;
 }
 
-int AlloyBrowserMainParts::PreMainMessageLoopRun() {
+void AlloyBrowserMainParts::PreMainMessageLoopRun() {
 #if defined(USE_AURA)
   display::Screen::SetScreenInstance(views::CreateDesktopScreen());
 #endif
@@ -174,14 +180,16 @@ int AlloyBrowserMainParts::PreMainMessageLoopRun() {
   // ChromeBrowserMainExtraPartsProfiles for details.
   cef::EnsureBrowserContextKeyedServiceFactoriesBuilt();
 
-  background_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::BEST_EFFORT,
+  printing::CefPrintingMessageFilter::EnsureShutdownNotifierFactoryBuilt();
+
+  background_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
-  user_visible_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::USER_VISIBLE,
+  user_visible_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
-  user_blocking_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::USER_BLOCKING,
+  user_blocking_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
 
   CefRequestContextSettings settings;
@@ -205,8 +213,6 @@ int AlloyBrowserMainParts::PreMainMessageLoopRun() {
   PluginFinder::GetInstance()->Init();
 
   scheme::RegisterWebUIControllerFactory();
-
-  return content::RESULT_CODE_NORMAL_EXIT;
 }
 
 void AlloyBrowserMainParts::PostMainMessageLoopRun() {

libcef/browser/alloy/alloy_browser_main.h

@@ -50,7 +50,7 @@ class AlloyBrowserMainParts : public content::BrowserMainParts {
   void PreMainMessageLoopStart() override;
   void PostMainMessageLoopStart() override;
   int PreCreateThreads() override;
-  int PreMainMessageLoopRun() override;
+  void PreMainMessageLoopRun() override;
   void PostMainMessageLoopRun() override;
   void PostDestroyThreads() override;
 

libcef/browser/alloy/alloy_content_browser_client.cc

@@ -29,6 +29,7 @@
 #include "libcef/browser/net_service/resource_request_handler_wrapper.h"
 #include "libcef/browser/plugins/plugin_service_filter.h"
 #include "libcef/browser/prefs/renderer_prefs.h"
+#include "libcef/browser/printing/printing_message_filter.h"
 #include "libcef/browser/speech_recognition_manager_delegate.h"
 #include "libcef/browser/ssl_info_impl.h"
 #include "libcef/browser/thread_util.h"
@@ -51,9 +52,8 @@
 #include "base/threading/thread_restrictions.h"
 #include "cef/grit/cef_resources.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
-#include "chrome/browser/net/profile_network_context_service.h"
-#include "chrome/browser/net/profile_network_context_service_factory.h"
 #include "chrome/browser/net/system_network_context_manager.h"
 #include "chrome/browser/plugins/plugin_info_host_impl.h"
 #include "chrome/browser/plugins/plugin_response_interceptor_url_loader_throttle.h"
@@ -73,8 +73,6 @@
 #include "chrome/grit/generated_resources.h"
 #include "chrome/services/printing/printing_service.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
-#include "components/embedder_support/switches.h"
-#include "components/embedder_support/user_agent_utils.h"
 #include "components/spellcheck/common/spellcheck.mojom.h"
 #include "components/version_info/version_info.h"
 #include "content/browser/plugin_service_impl.h"
@@ -95,6 +93,7 @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_ui_url_loader_factory.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/service_names.mojom.h"
 #include "content/public/common/storage_quota_params.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
@@ -253,7 +252,7 @@ class CefAllowCertificateErrorCallbackImpl : public CefRequestCallback {
     CEF_REQUIRE_UIT();
     std::move(callback).Run(
         allow ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE
-              : content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
+              : content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
   }
 
   CallbackType callback_;
@@ -503,6 +502,7 @@ void AlloyContentBrowserClient::RenderProcessWillLaunch(
   Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
 
   host->AddFilter(new CefBrowserMessageFilter(id));
+  host->AddFilter(new printing::CefPrintingMessageFilter(id, profile));
 
   if (extensions::ExtensionsEnabled()) {
     host->AddFilter(new extensions::ExtensionMessageFilter(id, profile));
@@ -695,9 +695,9 @@ void AlloyContentBrowserClient::AppendExtraCommandLineSwitches(
       switches::kLocalesDirPath,
       switches::kLogFile,
       switches::kLogSeverity,
+      switches::kProductVersion,
       switches::kResourcesDirPath,
-      embedder_support::kUserAgent,
-      switches::kUserAgentProductAndVersion,
+      switches::kUserAgent,
     };
     command_line->CopySwitchesFrom(*browser_cmd, kSwitchNames,
                                    base::size(kSwitchNames));
@@ -855,7 +855,7 @@ void AlloyContentBrowserClient::AllowCertificateError(
     // A sub-resource has a certificate error. The user doesn't really
     // have a context for making the right decision, so block the request
     // hard.
-    std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
+    std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
     return;
   }
 
@@ -882,7 +882,7 @@ void AlloyContentBrowserClient::AllowCertificateError(
     // |callback| may be null if the user executed it despite returning false.
     callback = callbackImpl->Disconnect();
     if (!callback.is_null()) {
-      std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
+      std::move(callback).Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
     }
   }
 }
@@ -951,10 +951,8 @@ bool AlloyContentBrowserClient::CanCreateWindow(
 }
 
 void AlloyContentBrowserClient::OverrideWebkitPrefs(
-    content::WebContents* web_contents,
+    content::RenderViewHost* rvh,
     blink::web_pref::WebPreferences* prefs) {
-  auto rvh = web_contents->GetRenderViewHost();
-
   // Using RVH instead of RFH here because rvh->GetMainFrame() may be nullptr
   // when this method is called.
   renderer_prefs::PopulateWebPreferences(rvh, *prefs);
@@ -988,9 +986,9 @@ void AlloyContentBrowserClient::DidCreatePpapiPlugin(
           new ChromeBrowserPepperHostFactory(browser_host)));
 }
 
-std::unique_ptr<content::DevToolsManagerDelegate>
-AlloyContentBrowserClient::CreateDevToolsManagerDelegate() {
-  return std::make_unique<CefDevToolsManagerDelegate>();
+content::DevToolsManagerDelegate*
+AlloyContentBrowserClient::GetDevToolsManagerDelegate() {
+  return new CefDevToolsManagerDelegate();
 }
 
 std::vector<std::unique_ptr<content::NavigationThrottle>>
@@ -1012,7 +1010,7 @@ AlloyContentBrowserClient::CreateURLLoaderThrottles(
 
   // Used to substitute View ID for PDF contents when using the PDF plugin.
   result.push_back(std::make_unique<PluginResponseInterceptorURLLoaderThrottle>(
-      request.destination, frame_tree_node_id));
+      request.resource_type, frame_tree_node_id));
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
 
@@ -1038,6 +1036,13 @@ void AlloyContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
 }
 #endif  // defined(OS_LINUX)
 
+#if defined(OS_WIN)
+bool AlloyContentBrowserClient::PreSpawnRenderer(sandbox::TargetPolicy* policy,
+                                                 RendererSpawnFlags flags) {
+  return true;
+}
+#endif  // defined(OS_WIN)
+
 void AlloyContentBrowserClient::ExposeInterfacesToRenderer(
     service_manager::BinderRegistry* registry,
     blink::AssociatedInterfaceRegistry* associated_registry,
@@ -1187,8 +1192,7 @@ void AlloyContentBrowserClient::ConfigureNetworkContextParams(
     bool in_memory,
     const base::FilePath& relative_partition_path,
     network::mojom::NetworkContextParams* network_context_params,
-    cert_verifier::mojom::CertVerifierCreationParams*
-        cert_verifier_creation_params) {
+    network::mojom::CertVerifierCreationParams* cert_verifier_creation_params) {
   // This method may be called during shutdown when using multi-threaded
   // message loop mode. In that case exit early to avoid crashes.
   if (!SystemNetworkContextManager::GetInstance()) {
@@ -1201,17 +1205,9 @@ void AlloyContentBrowserClient::ConfigureNetworkContextParams(
   auto cef_context = CefBrowserContext::FromBrowserContext(context);
 
   Profile* profile = cef_context->AsProfile();
-  ProfileNetworkContextService* service =
-      ProfileNetworkContextServiceFactory::GetForContext(profile);
-  if (service) {
-    service->ConfigureNetworkContextParams(in_memory, relative_partition_path,
-                                           network_context_params,
-                                           cert_verifier_creation_params);
-  } else {
-    // Set default params.
-    network_context_params->user_agent = GetUserAgent();
-    network_context_params->accept_language = GetApplicationLocale();
-  }
+  profile->ConfigureNetworkContextParams(in_memory, relative_partition_path,
+                                         network_context_params,
+                                         cert_verifier_creation_params);
 
   network_context_params->cookieable_schemes =
       cef_context->GetCookieableSchemes();
@@ -1244,7 +1240,6 @@ bool AlloyContentBrowserClient::HandleExternalProtocol(
     const GURL& url,
     content::WebContents::OnceGetter web_contents_getter,
     int child_id,
-    int frame_tree_node_id,
     content::NavigationUIData* navigation_data,
     bool is_main_frame,
     ui::PageTransition page_transition,
@@ -1323,7 +1318,8 @@ AlloyContentBrowserClient::GetSandboxedStorageServiceDataDirectory() {
 }
 
 std::string AlloyContentBrowserClient::GetProduct() {
-  return embedder_support::GetProduct();
+  // Match the logic in chrome_content_browser_client.cc GetProduct().
+  return ::GetProduct();
 }
 
 std::string AlloyContentBrowserClient::GetChromeProduct() {
@@ -1331,7 +1327,8 @@ std::string AlloyContentBrowserClient::GetChromeProduct() {
 }
 
 std::string AlloyContentBrowserClient::GetUserAgent() {
-  return embedder_support::GetUserAgent();
+  // Match the logic in chrome_content_browser_client.cc GetUserAgent().
+  return ::GetUserAgent();
 }
 
 blink::UserAgentMetadata AlloyContentBrowserClient::GetUserAgentMetadata() {

libcef/browser/alloy/alloy_content_browser_client.h

@@ -101,7 +101,7 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
                        bool user_gesture,
                        bool opener_suppressed,
                        bool* no_javascript_access) override;
-  void OverrideWebkitPrefs(content::WebContents* web_contents,
+  void OverrideWebkitPrefs(content::RenderViewHost* rvh,
                            blink::web_pref::WebPreferences* prefs) override;
   bool OverrideWebPreferencesAfterNavigation(
       content::WebContents* web_contents,
@@ -109,8 +109,7 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
   void BrowserURLHandlerCreated(content::BrowserURLHandler* handler) override;
   std::string GetDefaultDownloadName() override;
   void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
-  std::unique_ptr<content::DevToolsManagerDelegate>
-  CreateDevToolsManagerDelegate() override;
+  content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
   std::vector<std::unique_ptr<content::NavigationThrottle>>
   CreateThrottlesForNavigation(
       content::NavigationHandle* navigation_handle) override;
@@ -129,6 +128,11 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
       content::PosixFileDescriptorInfo* mappings) override;
 #endif
 
+#if defined(OS_WIN)
+  bool PreSpawnRenderer(sandbox::TargetPolicy* policy,
+                        RendererSpawnFlags flags) override;
+#endif
+
   void ExposeInterfacesToRenderer(
       service_manager::BinderRegistry* registry,
       blink::AssociatedInterfaceRegistry* associated_registry,
@@ -173,14 +177,13 @@ class AlloyContentBrowserClient : public content::ContentBrowserClient {
       bool in_memory,
       const base::FilePath& relative_partition_path,
       network::mojom::NetworkContextParams* network_context_params,
-      cert_verifier::mojom::CertVerifierCreationParams*
-          cert_verifier_creation_params) override;
+      network::mojom::CertVerifierCreationParams* cert_verifier_creation_params)
+      override;
   std::vector<base::FilePath> GetNetworkContextsParentDirectory() override;
   bool HandleExternalProtocol(
       const GURL& url,
       content::WebContents::OnceGetter web_contents_getter,
       int child_id,
-      int frame_tree_node_id,
       content::NavigationUIData* navigation_data,
       bool is_main_frame,
       ui::PageTransition page_transition,

libcef/browser/alloy/browser_platform_delegate_alloy.cc

@@ -12,7 +12,6 @@
 #include "libcef/browser/extensions/extension_web_contents_observer.h"
 #include "libcef/browser/printing/print_view_manager.h"
 #include "libcef/common/extensions/extensions_util.h"
-#include "libcef/common/net/url_util.h"
 #include "libcef/features/runtime_checks.h"
 
 #include "base/logging.h"
@@ -59,20 +58,18 @@ content::WebContents* CefBrowserPlatformDelegateAlloy::CreateWebContents(
   }
 
   scoped_refptr<content::SiteInstance> site_instance;
-  if (extensions::ExtensionsEnabled() && !create_params.url.empty()) {
-    GURL gurl = url_util::MakeGURL(create_params.url, /*fixup=*/true);
+  if (extensions::ExtensionsEnabled() && !create_params.url.is_empty()) {
     if (!create_params.extension) {
       // We might be loading an extension app view where the extension URL is
       // provided by the client.
       create_params.extension =
-          extensions::GetExtensionForUrl(browser_context, gurl);
+          extensions::GetExtensionForUrl(browser_context, create_params.url);
     }
     if (create_params.extension) {
-      if (create_params.extension_host_type ==
-          extensions::mojom::ViewType::kInvalid) {
+      if (create_params.extension_host_type == extensions::VIEW_TYPE_INVALID) {
         // Default to dialog behavior.
         create_params.extension_host_type =
-            extensions::mojom::ViewType::kExtensionDialog;
+            extensions::VIEW_TYPE_EXTENSION_DIALOG;
       }
 
       // Extension resources will fail to load if we don't use a SiteInstance
@@ -82,7 +79,7 @@ content::WebContents* CefBrowserPlatformDelegateAlloy::CreateWebContents(
       // ExtensionProtocolHandler::MaybeCreateJob will return false resulting in
       // ERR_BLOCKED_BY_CLIENT).
       site_instance = extensions::ProcessManager::Get(browser_context)
-                          ->GetSiteInstanceForURL(gurl);
+                          ->GetSiteInstanceForURL(create_params.url);
       DCHECK(site_instance);
     }
   }
@@ -192,7 +189,7 @@ void CefBrowserPlatformDelegateAlloy::BrowserCreated(
 void CefBrowserPlatformDelegateAlloy::CreateExtensionHost(
     const extensions::Extension* extension,
     const GURL& url,
-    extensions::mojom::ViewType host_type) {
+    extensions::ViewType host_type) {
   REQUIRE_ALLOY_RUNTIME();
   DCHECK(primary_);
 
@@ -203,15 +200,14 @@ void CefBrowserPlatformDelegateAlloy::CreateExtensionHost(
 
   auto alloy_browser = static_cast<AlloyBrowserHostImpl*>(browser_);
 
-  if (host_type == extensions::mojom::ViewType::kExtensionDialog ||
-      host_type == extensions::mojom::ViewType::kExtensionPopup) {
+  if (host_type == extensions::VIEW_TYPE_EXTENSION_DIALOG ||
+      host_type == extensions::VIEW_TYPE_EXTENSION_POPUP) {
     // Create an extension host that we own.
     extension_host_ = new extensions::CefExtensionViewHost(
         alloy_browser, extension, web_contents_, url, host_type);
     // Trigger load of the extension URL.
-    extension_host_->CreateRendererSoon();
-  } else if (host_type ==
-             extensions::mojom::ViewType::kExtensionBackgroundPage) {
+    extension_host_->CreateRenderViewSoon();
+  } else if (host_type == extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     is_background_host_ = true;
     alloy_browser->is_background_host_ = true;
     // Create an extension host that will be owned by ProcessManager.
@@ -453,7 +449,7 @@ void CefBrowserPlatformDelegateAlloy::DestroyExtensionHost() {
   if (!extension_host_)
     return;
   if (extension_host_->extension_host_type() ==
-      extensions::mojom::ViewType::kExtensionBackgroundPage) {
+      extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     DCHECK(is_background_host_);
     // Close notification for background pages arrives via CloseContents.
     // The extension host will be deleted by

libcef/browser/alloy/browser_platform_delegate_alloy.h

@@ -33,7 +33,7 @@ class CefBrowserPlatformDelegateAlloy : public CefBrowserPlatformDelegate {
   void BrowserCreated(CefBrowserHostBase* browser) override;
   void CreateExtensionHost(const extensions::Extension* extension,
                            const GURL& url,
-                           extensions::mojom::ViewType host_type) override;
+                           extensions::ViewType host_type) override;
   extensions::ExtensionHost* GetExtensionHost() const override;
   void BrowserDestroyed(CefBrowserHostBase* browser) override;
   void SendCaptureLostEvent() override;

libcef/browser/alloy/chrome_browser_process_alloy.cc

@@ -128,6 +128,11 @@ metrics::MetricsService* ChromeBrowserProcessAlloy::metrics_service() {
   return nullptr;
 }
 
+rappor::RapporServiceImpl* ChromeBrowserProcessAlloy::rappor_service() {
+  // Called from PluginInfoHostImpl::ReportMetrics.
+  return nullptr;
+}
+
 SystemNetworkContextManager*
 ChromeBrowserProcessAlloy::system_network_context_manager() {
   DCHECK(SystemNetworkContextManager::GetInstance());
@@ -320,6 +325,12 @@ ChromeBrowserProcessAlloy::floc_sorting_lsh_clusters_service() {
   return nullptr;
 }
 
+optimization_guide::OptimizationGuideService*
+ChromeBrowserProcessAlloy::optimization_guide_service() {
+  NOTREACHED();
+  return nullptr;
+}
+
 StartupData* ChromeBrowserProcessAlloy::startup_data() {
   NOTREACHED();
   return nullptr;

libcef/browser/alloy/chrome_browser_process_alloy.h

@@ -44,6 +44,7 @@ class ChromeBrowserProcessAlloy : public BrowserProcess {
   metrics_services_manager::MetricsServicesManager* GetMetricsServicesManager()
       override;
   metrics::MetricsService* metrics_service() override;
+  rappor::RapporServiceImpl* rappor_service() override;
   SystemNetworkContextManager* system_network_context_manager() override;
   network::NetworkQualityTracker* network_quality_tracker() override;
   WatchDogThread* watchdog_thread() override;
@@ -83,6 +84,8 @@ class ChromeBrowserProcessAlloy : public BrowserProcess {
       override;
   federated_learning::FlocSortingLshClustersService*
   floc_sorting_lsh_clusters_service() override;
+  optimization_guide::OptimizationGuideService* optimization_guide_service()
+      override;
   StartupData* startup_data() override;
 
 #if defined(OS_WIN) || defined(OS_LINUX)

libcef/browser/alloy/chrome_profile_alloy.cc

@@ -71,8 +71,7 @@ std::string ChromeProfileAlloy::GetProfileUserName() const {
 }
 
 Profile* ChromeProfileAlloy::GetOffTheRecordProfile(
-    const Profile::OTRProfileID& otr_profile_id,
-    bool create_if_needed) {
+    const Profile::OTRProfileID& otr_profile_id) {
   NOTREACHED();
   return nullptr;
 }
@@ -110,6 +109,10 @@ bool ChromeProfileAlloy::IsChild() const {
   return false;
 }
 
+bool ChromeProfileAlloy::IsLegacySupervised() const {
+  return false;
+}
+
 ExtensionSpecialStoragePolicy*
 ChromeProfileAlloy::GetExtensionSpecialStoragePolicy() {
   NOTREACHED();
@@ -173,8 +176,3 @@ void ChromeProfileAlloy::SetCreationTimeForTesting(base::Time creation_time) {
 void ChromeProfileAlloy::RecordMainFrameNavigation() {
   NOTREACHED();
 }
-
-bool ChromeProfileAlloy::IsSignedIn() {
-  NOTREACHED();
-  return false;
-}

libcef/browser/alloy/chrome_profile_alloy.h

@@ -26,8 +26,8 @@ class ChromeProfileAlloy : public Profile {
   variations::VariationsClient* GetVariationsClient() override;
   scoped_refptr<base::SequencedTaskRunner> GetIOTaskRunner() override;
   std::string GetProfileUserName() const override;
-  Profile* GetOffTheRecordProfile(const Profile::OTRProfileID& otr_profile_id,
-                                  bool create_if_needed) override;
+  Profile* GetOffTheRecordProfile(
+      const Profile::OTRProfileID& otr_profile_id) override;
   std::vector<Profile*> GetAllOffTheRecordProfiles() override;
   void DestroyOffTheRecordProfile(Profile* otr_profile) override;
   bool HasOffTheRecordProfile(
@@ -37,6 +37,7 @@ class ChromeProfileAlloy : public Profile {
   const Profile* GetOriginalProfile() const override;
   bool IsSupervised() const override;
   bool IsChild() const override;
+  bool IsLegacySupervised() const override;
   ExtensionSpecialStoragePolicy* GetExtensionSpecialStoragePolicy() override;
   PrefService* GetOffTheRecordPrefs() override;
   bool IsSameOrParent(Profile* profile) override;
@@ -50,7 +51,6 @@ class ChromeProfileAlloy : public Profile {
   base::Time GetCreationTime() const override;
   void SetCreationTimeForTesting(base::Time creation_time) override;
   void RecordMainFrameNavigation() override;
-  bool IsSignedIn() override;
 
  private:
   std::unique_ptr<variations::VariationsClient> variations_client_;

libcef/browser/browser_contents_delegate.cc

@@ -16,7 +16,6 @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
-#include "third_party/blink/public/mojom/favicon/favicon_url.mojom.h"
 
 using content::KeyboardEventProcessingResult;
 
@@ -42,7 +41,9 @@ void CefBrowserContentsDelegate::ObserveWebContents(
                     content::Source<content::NavigationController>(
                         &new_contents->GetController()));
 
-    // Make sure RenderFrameCreated is called at least one time.
+    // Make sure RenderViewCreated is called at least one time.
+    RenderViewCreated(new_contents->GetRenderViewHost());
+
     // Create the frame representation before OnAfterCreated is called for a new
     // browser. Additionally, RenderFrameCreated is otherwise not called at all
     // for new popup browsers.
@@ -69,12 +70,9 @@ content::WebContents* CefBrowserContentsDelegate::OpenURLFromTab(
 
   if (auto c = client()) {
     if (auto handler = c->GetRequestHandler()) {
-      // May return nullptr for omnibox navigations.
-      auto frame = browser()->GetFrame(params.frame_tree_node_id);
-      if (!frame)
-        frame = browser()->GetMainFrame();
       cancel = handler->OnOpenURLFromTab(
-          browser(), frame, params.url.spec(),
+          browser(), browser()->GetFrame(params.frame_tree_node_id),
+          params.url.spec(),
           static_cast<cef_window_open_disposition_t>(params.disposition),
           params.user_gesture);
     }
@@ -109,7 +107,6 @@ void CefBrowserContentsDelegate::LoadingStateChanged(
 
   if (auto c = client()) {
     if (auto handler = c->GetLoadHandler()) {
-      auto navigation_lock = browser_info_->CreateNavigationLock();
       handler->OnLoadingStateChange(browser(), is_loading, can_go_back,
                                     can_go_forward);
     }
@@ -128,9 +125,9 @@ void CefBrowserContentsDelegate::UpdateTargetURL(content::WebContents* source,
 bool CefBrowserContentsDelegate::DidAddMessageToConsole(
     content::WebContents* source,
     blink::mojom::ConsoleMessageLevel log_level,
-    const std::u16string& message,
+    const base::string16& message,
     int32_t line_no,
-    const std::u16string& source_id) {
+    const base::string16& source_id) {
   if (auto c = client()) {
     if (auto handler = c->GetDisplayHandler()) {
       // Use LOGSEVERITY_DEBUG for unrecognized |level| values.
@@ -232,18 +229,6 @@ bool CefBrowserContentsDelegate::HandleKeyboardEvent(
 void CefBrowserContentsDelegate::RenderFrameCreated(
     content::RenderFrameHost* render_frame_host) {
   browser_info_->MaybeCreateFrame(render_frame_host, false /* is_guest_view */);
-
-  if (render_frame_host->GetParent() == nullptr) {
-    // May be already registered if the renderer crashed previously.
-    auto render_view_host = render_frame_host->GetRenderViewHost();
-    if (!registrar_->IsRegistered(
-            this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
-            content::Source<content::RenderViewHost>(render_view_host))) {
-      registrar_->Add(
-          this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
-          content::Source<content::RenderViewHost>(render_view_host));
-    }
-  }
 }
 
 void CefBrowserContentsDelegate::RenderFrameHostChanged(
@@ -264,6 +249,17 @@ void CefBrowserContentsDelegate::RenderFrameDeleted(
   }
 }
 
+void CefBrowserContentsDelegate::RenderViewCreated(
+    content::RenderViewHost* render_view_host) {
+  // May be already registered if the renderer crashed previously.
+  if (!registrar_->IsRegistered(
+          this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
+          content::Source<content::RenderViewHost>(render_view_host))) {
+    registrar_->Add(this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
+                    content::Source<content::RenderViewHost>(render_view_host));
+  }
+}
+
 void CefBrowserContentsDelegate::RenderViewDeleted(
     content::RenderViewHost* render_view_host) {
   if (registrar_->IsRegistered(
@@ -329,8 +325,7 @@ void CefBrowserContentsDelegate::OnFrameFocused(
   OnStateChanged(State::kFocusedFrame);
 }
 
-void CefBrowserContentsDelegate::DocumentAvailableInMainFrame(
-    content::RenderFrameHost* render_frame_host) {
+void CefBrowserContentsDelegate::DocumentAvailableInMainFrame() {
   has_document_ = true;
   OnStateChanged(State::kDocument);
 
@@ -513,7 +508,6 @@ void CefBrowserContentsDelegate::OnLoadEnd(CefRefPtr<CefFrame> frame,
                                            int http_status_code) {
   if (auto c = client()) {
     if (auto handler = c->GetLoadHandler()) {
-      auto navigation_lock = browser_info_->CreateNavigationLock();
       handler->OnLoadEnd(browser(), frame, http_status_code);
     }
   }
@@ -572,7 +566,6 @@ void CefBrowserContentsDelegate::OnLoadStart(
     ui::PageTransition transition_type) {
   if (auto c = client()) {
     if (auto handler = c->GetLoadHandler()) {
-      auto navigation_lock = browser_info_->CreateNavigationLock();
       // On the handler that loading has started.
       handler->OnLoadStart(browser(), frame,
                            static_cast<cef_transition_type_t>(transition_type));
@@ -594,7 +587,7 @@ void CefBrowserContentsDelegate::OnLoadError(CefRefPtr<CefFrame> frame,
   }
 }
 
-void CefBrowserContentsDelegate::OnTitleChange(const std::u16string& title) {
+void CefBrowserContentsDelegate::OnTitleChange(const base::string16& title) {
   if (auto c = client()) {
     if (auto handler = c->GetDisplayHandler()) {
       handler->OnTitleChange(browser(), title);

libcef/browser/browser_contents_delegate.h

@@ -87,9 +87,9 @@ class CefBrowserContentsDelegate : public content::WebContentsDelegate,
   void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
   bool DidAddMessageToConsole(content::WebContents* source,
                               blink::mojom::ConsoleMessageLevel log_level,
-                              const std::u16string& message,
+                              const base::string16& message,
                               int32_t line_no,
-                              const std::u16string& source_id) override;
+                              const base::string16& source_id) override;
   void DidNavigateMainFramePostCommit(
       content::WebContents* web_contents) override;
   void EnterFullscreenModeForTab(
@@ -108,12 +108,12 @@ class CefBrowserContentsDelegate : public content::WebContentsDelegate,
   void RenderFrameHostChanged(content::RenderFrameHost* old_host,
                               content::RenderFrameHost* new_host) override;
   void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
+  void RenderViewCreated(content::RenderViewHost* render_view_host) override;
   void RenderViewDeleted(content::RenderViewHost* render_view_host) override;
   void RenderViewReady() override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void OnFrameFocused(content::RenderFrameHost* render_frame_host) override;
-  void DocumentAvailableInMainFrame(
-      content::RenderFrameHost* render_frame_host) override;
+  void DocumentAvailableInMainFrame() override;
   void LoadProgressChanged(double progress) override;
   void DidStopLoading() override;
   void DidFinishNavigation(
@@ -164,7 +164,7 @@ class CefBrowserContentsDelegate : public content::WebContentsDelegate,
   void OnLoadStart(CefRefPtr<CefFrame> frame,
                    ui::PageTransition transition_type);
   void OnLoadError(CefRefPtr<CefFrame> frame, const GURL& url, int error_code);
-  void OnTitleChange(const std::u16string& title);
+  void OnTitleChange(const base::string16& title);
   void OnFullscreenModeChange(bool fullscreen);
 
   void OnStateChanged(State state_changed);

libcef/browser/browser_context.cc

@@ -7,20 +7,16 @@
 #include <map>
 #include <utility>
 
-#include "libcef/browser/context.h"
+#include "libcef/browser/iothread_state.h"
 #include "libcef/browser/media_router/media_router_manager.h"
 #include "libcef/browser/request_context_impl.h"
 #include "libcef/browser/thread_util.h"
 #include "libcef/common/cef_switches.h"
-#include "libcef/features/runtime.h"
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/no_destructor.h"
-#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
@@ -145,28 +141,6 @@ CefBrowserContext* GetSelf(base::WeakPtr<CefBrowserContext> self) {
   return self.get();
 }
 
-CefBrowserContext::CookieableSchemes MakeSupportedSchemes(
-    const CefString& schemes_list,
-    bool include_defaults) {
-  std::vector<std::string> all_schemes;
-  if (!schemes_list.empty()) {
-    all_schemes =
-        base::SplitString(schemes_list.ToString(), std::string(","),
-                          base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  }
-
-  if (include_defaults) {
-    // Add default schemes that should always support cookies.
-    // This list should match CookieMonster::kDefaultCookieableSchemes.
-    all_schemes.push_back("http");
-    all_schemes.push_back("https");
-    all_schemes.push_back("ws");
-    all_schemes.push_back("wss");
-  }
-
-  return base::make_optional(all_schemes);
-}
-
 }  // namespace
 
 CefBrowserContext::CefBrowserContext(const CefRequestContextSettings& settings)
@@ -180,6 +154,13 @@ CefBrowserContext::~CefBrowserContext() {
 #if DCHECK_IS_ON()
   DCHECK(is_shutdown_);
 #endif
+
+  if (iothread_state_) {
+    // Destruction of the CefIOThreadState will trigger destruction of all
+    // associated network requests.
+    content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
+                                       iothread_state_.release());
+  }
 }
 
 void CefBrowserContext::Initialize() {
@@ -188,14 +169,7 @@ void CefBrowserContext::Initialize() {
   if (!cache_path_.empty())
     g_manager.Get().SetImplPath(this, cache_path_);
 
-  iothread_state_ = base::MakeRefCounted<CefIOThreadState>();
-
-  if (settings_.cookieable_schemes_list.length > 0 ||
-      settings_.cookieable_schemes_exclude_defaults) {
-    cookieable_schemes_ =
-        MakeSupportedSchemes(CefString(&settings_.cookieable_schemes_list),
-                             !settings_.cookieable_schemes_exclude_defaults);
-  }
+  iothread_state_ = std::make_unique<CefIOThreadState>();
 }
 
 void CefBrowserContext::Shutdown() {
@@ -255,25 +229,6 @@ CefBrowserContext* CefBrowserContext::FromBrowserContext(
   return g_manager.Get().GetImplFromBrowserContext(context);
 }
 
-// static
-CefBrowserContext* CefBrowserContext::FromProfile(const Profile* profile) {
-  auto* cef_context = FromBrowserContext(profile);
-  if (cef_context)
-    return cef_context;
-
-  if (cef::IsChromeRuntimeEnabled()) {
-    auto* original_profile = profile->GetOriginalProfile();
-    if (original_profile != profile) {
-      // With the Chrome runtime if the user launches an incognito window via
-      // the UI we might be associated with the original Profile instead of the
-      // (current) incognito profile.
-      return FromBrowserContext(original_profile);
-    }
-  }
-
-  return nullptr;
-}
-
 // static
 std::vector<CefBrowserContext*> CefBrowserContext::GetAll() {
   return g_manager.Get().GetAllImpl();
@@ -299,10 +254,15 @@ void CefBrowserContext::OnRenderFrameCreated(
     handler_map_.AddHandler(render_process_id, render_frame_id,
                             frame_tree_node_id, handler);
 
-    CEF_POST_TASK(CEF_IOT,
-                  base::Bind(&CefIOThreadState::AddHandler, iothread_state_,
-                             render_process_id, render_frame_id,
-                             frame_tree_node_id, handler));
+    if (iothread_state_) {
+      // Using base::Unretained() is safe because both this callback and
+      // possible deletion of |iothread_state_| will execute on the IO thread,
+      // and this callback will be executed first.
+      CEF_POST_TASK(CEF_IOT, base::Bind(&CefIOThreadState::AddHandler,
+                                        base::Unretained(iothread_state_.get()),
+                                        render_process_id, render_frame_id,
+                                        frame_tree_node_id, handler));
+    }
   }
 }
 
@@ -332,9 +292,15 @@ void CefBrowserContext::OnRenderFrameDeleted(
     handler_map_.RemoveHandler(render_process_id, render_frame_id,
                                frame_tree_node_id);
 
-    CEF_POST_TASK(CEF_IOT, base::Bind(&CefIOThreadState::RemoveHandler,
-                                      iothread_state_, render_process_id,
-                                      render_frame_id, frame_tree_node_id));
+    if (iothread_state_) {
+      // Using base::Unretained() is safe because both this callback and
+      // possible deletion of |iothread_state_| will execute on the IO thread,
+      // and this callback will be executed first.
+      CEF_POST_TASK(CEF_IOT, base::Bind(&CefIOThreadState::RemoveHandler,
+                                        base::Unretained(iothread_state_.get()),
+                                        render_process_id, render_frame_id,
+                                        frame_tree_node_id));
+    }
   }
 
   if (is_main_frame) {
@@ -438,15 +404,26 @@ void CefBrowserContext::RegisterSchemeHandlerFactory(
     const CefString& scheme_name,
     const CefString& domain_name,
     CefRefPtr<CefSchemeHandlerFactory> factory) {
-  CEF_POST_TASK(CEF_IOT,
-                base::Bind(&CefIOThreadState::RegisterSchemeHandlerFactory,
-                           iothread_state_, scheme_name, domain_name, factory));
+  if (iothread_state_) {
+    // Using base::Unretained() is safe because both this callback and possible
+    // deletion of |iothread_state_| will execute on the IO thread, and this
+    // callback will be executed first.
+    CEF_POST_TASK(CEF_IOT,
+                  base::Bind(&CefIOThreadState::RegisterSchemeHandlerFactory,
+                             base::Unretained(iothread_state_.get()),
+                             scheme_name, domain_name, factory));
+  }
 }
 
 void CefBrowserContext::ClearSchemeHandlerFactories() {
-  CEF_POST_TASK(CEF_IOT,
-                base::Bind(&CefIOThreadState::ClearSchemeHandlerFactories,
-                           iothread_state_));
+  if (iothread_state_) {
+    // Using base::Unretained() is safe because both this callback and possible
+    // deletion of |iothread_state_| will execute on the IO thread, and this
+    // callback will be executed first.
+    CEF_POST_TASK(CEF_IOT,
+                  base::Bind(&CefIOThreadState::ClearSchemeHandlerFactories,
+                             base::Unretained(iothread_state_.get())));
+  }
 }
 
 void CefBrowserContext::LoadExtension(
@@ -500,24 +477,5 @@ CefBrowserContext::CookieableSchemes CefBrowserContext::GetCookieableSchemes()
   if (cookieable_schemes_)
     return cookieable_schemes_;
 
-  return GetGlobalCookieableSchemes();
-}
-
-// static
-CefBrowserContext::CookieableSchemes
-CefBrowserContext::GetGlobalCookieableSchemes() {
-  CEF_REQUIRE_UIT();
-
-  static base::NoDestructor<CookieableSchemes> schemes(
-      []() -> CookieableSchemes {
-        const auto& settings = CefContext::Get()->settings();
-        if (settings.cookieable_schemes_list.length > 0 ||
-            settings.cookieable_schemes_exclude_defaults) {
-          return MakeSupportedSchemes(
-              CefString(&settings.cookieable_schemes_list),
-              !settings.cookieable_schemes_exclude_defaults);
-        }
-        return base::nullopt;
-      }());
-  return *schemes;
+  return CefCookieManagerImpl::GetGlobalCookieableSchemes();
 }

libcef/browser/browser_context.h

@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "include/cef_request_context_handler.h"
-#include "libcef/browser/iothread_state.h"
 #include "libcef/browser/request_context_handler_map.h"
 
 #include "base/callback.h"
@@ -81,6 +80,7 @@ class BrowserContext;
 
 class CefMediaRouterManager;
 class CefRequestContextImpl;
+class CefIOThreadState;
 class Profile;
 
 // Main entry point for configuring behavior on a per-RequestContext basis. The
@@ -103,7 +103,6 @@ class CefBrowserContext {
   // Returns the underlying CefBrowserContext if any.
   static CefBrowserContext* FromBrowserContext(
       const content::BrowserContext* context);
-  static CefBrowserContext* FromProfile(const Profile* profile);
 
   // Returns all existing CefBrowserContext.
   static std::vector<CefBrowserContext*> GetAll();
@@ -112,13 +111,6 @@ class CefBrowserContext {
   virtual content::BrowserContext* AsBrowserContext() = 0;
   virtual Profile* AsProfile() = 0;
 
-  // Returns true if the context is fully initialized.
-  virtual bool IsInitialized() const = 0;
-
-  // If the context is fully initialized execute |callback|, otherwise
-  // store it until the context is fully initialized.
-  virtual void StoreOrTriggerInitCallback(base::OnceClosure callback) = 0;
-
   // Called from CefRequestContextImpl to track associated objects. This
   // object will delete itself when the count reaches zero.
   void AddCefRequestContext(CefRequestContextImpl* context);
@@ -205,15 +197,17 @@ class CefBrowserContext {
   // Returns the schemes associated with this context specifically, or the
   // global configuration if unset.
   CookieableSchemes GetCookieableSchemes() const;
-  static CookieableSchemes GetGlobalCookieableSchemes();
+
+  // Set the schemes associated with this context specifically.
+  void set_cookieable_schemes(const CookieableSchemes& schemes) {
+    cookieable_schemes_ = schemes;
+  }
 
   // These accessors are safe to call from any thread because the values don't
   // change during this object's lifespan.
   const CefRequestContextSettings& settings() const { return settings_; }
   base::FilePath cache_path() const { return cache_path_; }
-  scoped_refptr<CefIOThreadState> iothread_state() const {
-    return iothread_state_;
-  }
+  CefIOThreadState* iothread_state() const { return iothread_state_.get(); }
 
   // Used to hold a WeakPtr reference to this this object. The Getter returns
   // nullptr if this object has already been destroyed.
@@ -236,7 +230,7 @@ class CefBrowserContext {
   base::FilePath cache_path_;
 
  private:
-  scoped_refptr<CefIOThreadState> iothread_state_;
+  std::unique_ptr<CefIOThreadState> iothread_state_;
   CookieableSchemes cookieable_schemes_;
   std::unique_ptr<CefMediaRouterManager> media_router_manager_;
 

libcef/browser/browser_host_base.cc

@@ -6,17 +6,16 @@
 
 #include "libcef/browser/browser_info_manager.h"
 #include "libcef/browser/browser_platform_delegate.h"
-#include "libcef/browser/context.h"
 #include "libcef/browser/image_impl.h"
 #include "libcef/browser/navigation_entry_impl.h"
 #include "libcef/browser/thread_util.h"
-#include "libcef/common/net/url_util.h"
 
 #include "base/logging.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "components/favicon/core/favicon_url.h"
 #include "components/spellcheck/common/spellcheck_features.h"
+#include "components/url_formatter/url_fixer.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_request_utils.h"
@@ -164,8 +163,7 @@ CefBrowserHostBase::CefBrowserHostBase(
       client_(client),
       platform_delegate_(std::move(platform_delegate)),
       browser_info_(browser_info),
-      request_context_(request_context),
-      is_views_hosted_(platform_delegate_->IsViewsHosted()) {
+      request_context_(request_context) {
   CEF_REQUIRE_UIT();
   DCHECK(!browser_info_->browser().get());
   browser_info_->SetBrowser(this);
@@ -186,8 +184,6 @@ void CefBrowserHostBase::InitializeBrowser() {
 void CefBrowserHostBase::DestroyBrowser() {
   CEF_REQUIRE_UIT();
 
-  devtools_manager_.reset(nullptr);
-
   platform_delegate_.reset(nullptr);
 
   contents_delegate_->RemoveObserver(this);
@@ -209,10 +205,6 @@ CefRefPtr<CefRequestContext> CefBrowserHostBase::GetRequestContext() {
   return request_context_;
 }
 
-bool CefBrowserHostBase::HasView() {
-  return is_views_hosted_;
-}
-
 void CefBrowserHostBase::StartDownload(const CefString& url) {
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(
@@ -292,54 +284,6 @@ void CefBrowserHostBase::DownloadImage(
           max_image_size, callback));
 }
 
-bool CefBrowserHostBase::SendDevToolsMessage(const void* message,
-                                             size_t message_size) {
-  if (!message || message_size == 0)
-    return false;
-
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    std::string message_str(static_cast<const char*>(message), message_size);
-    CEF_POST_TASK(
-        CEF_UIT,
-        base::BindOnce(
-            [](CefRefPtr<CefBrowserHostBase> self, std::string message_str) {
-              self->SendDevToolsMessage(message_str.data(), message_str.size());
-            },
-            CefRefPtr<CefBrowserHostBase>(this), std::move(message_str)));
-    return false;
-  }
-
-  if (!EnsureDevToolsManager())
-    return false;
-  return devtools_manager_->SendDevToolsMessage(message, message_size);
-}
-
-int CefBrowserHostBase::ExecuteDevToolsMethod(
-    int message_id,
-    const CefString& method,
-    CefRefPtr<CefDictionaryValue> params) {
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    CEF_POST_TASK(
-        CEF_UIT, base::BindOnce(base::IgnoreResult(
-                                    &CefBrowserHostBase::ExecuteDevToolsMethod),
-                                this, message_id, method, params));
-    return 0;
-  }
-
-  if (!EnsureDevToolsManager())
-    return 0;
-  return devtools_manager_->ExecuteDevToolsMethod(message_id, method, params);
-}
-
-CefRefPtr<CefRegistration> CefBrowserHostBase::AddDevToolsMessageObserver(
-    CefRefPtr<CefDevToolsMessageObserver> observer) {
-  if (!observer)
-    return nullptr;
-  auto registration = CefDevToolsManager::CreateRegistration(observer);
-  InitializeDevToolsRegistrationOnUIThread(registration);
-  return registration.get();
-}
-
 void CefBrowserHostBase::GetNavigationEntries(
     CefRefPtr<CefNavigationEntryVisitor> visitor,
     bool current_only) {
@@ -762,9 +706,16 @@ bool CefBrowserHostBase::Navigate(const content::OpenURLParams& params) {
   CEF_REQUIRE_UIT();
   auto web_contents = GetWebContents();
   if (web_contents) {
-    GURL gurl = params.url;
-    if (!url_util::FixupGURL(gurl))
+    // Fix common problems with user-typed text. Among other things, this:
+    // - Converts absolute file paths to "file://" URLs.
+    // - Normalizes "about:" and "chrome:" to "chrome://" URLs.
+    // - Adds the "http://" scheme if none was specified.
+    GURL gurl = url_formatter::FixupURL(params.url.possibly_invalid_spec(),
+                                        std::string());
+    if (!gurl.is_valid()) {
+      LOG(ERROR) << "Invalid URL: " << params.url.possibly_invalid_spec();
       return false;
+    }
 
     web_contents->GetController().LoadURL(
         gurl, params.referrer, params.transition, params.extra_headers);
@@ -827,16 +778,6 @@ int CefBrowserHostBase::browser_id() const {
   return browser_info_->browser_id();
 }
 
-SkColor CefBrowserHostBase::GetBackgroundColor() const {
-  // Don't use |platform_delegate_| because it's not thread-safe.
-  return CefContext::Get()->GetBackgroundColor(
-      &settings_, IsWindowless() ? STATE_ENABLED : STATE_DISABLED);
-}
-
-bool CefBrowserHostBase::IsWindowless() const {
-  return false;
-}
-
 content::WebContents* CefBrowserHostBase::GetWebContents() const {
   CEF_REQUIRE_UIT();
   return contents_delegate_->web_contents();
@@ -849,46 +790,3 @@ content::BrowserContext* CefBrowserHostBase::GetBrowserContext() const {
     return web_contents->GetBrowserContext();
   return nullptr;
 }
-
-#if defined(TOOLKIT_VIEWS)
-views::Widget* CefBrowserHostBase::GetWindowWidget() const {
-  CEF_REQUIRE_UIT();
-  if (!platform_delegate_)
-    return nullptr;
-  return platform_delegate_->GetWindowWidget();
-}
-
-CefRefPtr<CefBrowserView> CefBrowserHostBase::GetBrowserView() const {
-  CEF_REQUIRE_UIT();
-  if (is_views_hosted_ && platform_delegate_)
-    return platform_delegate_->GetBrowserView();
-  return nullptr;
-}
-#endif  // defined(TOOLKIT_VIEWS)
-
-bool CefBrowserHostBase::EnsureDevToolsManager() {
-  CEF_REQUIRE_UIT();
-  if (!contents_delegate_->web_contents())
-    return false;
-
-  if (!devtools_manager_) {
-    devtools_manager_.reset(new CefDevToolsManager(this));
-  }
-  return true;
-}
-
-void CefBrowserHostBase::InitializeDevToolsRegistrationOnUIThread(
-    CefRefPtr<CefRegistration> registration) {
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    CEF_POST_TASK(
-        CEF_UIT,
-        base::BindOnce(
-            &CefBrowserHostBase::InitializeDevToolsRegistrationOnUIThread, this,
-            registration));
-    return;
-  }
-
-  if (!EnsureDevToolsManager())
-    return;
-  devtools_manager_->InitializeRegistrationOnUIThread(registration);
-}

libcef/browser/browser_host_base.h

@@ -12,13 +12,12 @@
 #include "libcef/browser/browser_contents_delegate.h"
 #include "libcef/browser/browser_info.h"
 #include "libcef/browser/browser_platform_delegate.h"
-#include "libcef/browser/devtools/devtools_manager.h"
 #include "libcef/browser/frame_host_impl.h"
 #include "libcef/browser/request_context_impl.h"
 
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
-#include "extensions/common/mojom/view_type.mojom.h"
+#include "extensions/common/view_type.h"
 
 namespace extensions {
 class Extension;
@@ -39,9 +38,6 @@ struct CefBrowserCreateParams {
     settings = that.settings;
     request_context = that.request_context;
     extra_info = that.extra_info;
-#if defined(TOOLKIT_VIEWS)
-    browser_view = that.browser_view;
-#endif
     return *this;
   }
 
@@ -49,15 +45,11 @@ struct CefBrowserCreateParams {
   // views-hosted browser. Currently used with the alloy runtime only.
   std::unique_ptr<CefWindowInfo> window_info;
 
-#if defined(TOOLKIT_VIEWS)
-  // The BrowserView that will own a Views-hosted browser. Will be nullptr for
-  // popup browsers.
+#if defined(USE_AURA)
+  // The BrowserView that will own a views-hosted browser. Will be nullptr for
+  // popup browsers (the BrowserView will be created later in that case).
+  // Currently used with the alloy runtime only.
   CefRefPtr<CefBrowserView> browser_view;
-
-  // True if this browser is a popup and has a Views-hosted opener, in which
-  // case the BrowserView for this browser will be created later (from
-  // PopupWebContentsCreated).
-  bool popup_with_views_hosted_opener = false;
 #endif
 
   // Client implementation. May be nullptr.
@@ -65,7 +57,7 @@ struct CefBrowserCreateParams {
 
   // Initial URL to load. May be empty. If this is a valid extension URL then
   // the browser will be created as an app view extension host.
-  CefString url;
+  GURL url;
 
   // Browser settings.
   CefBrowserSettings settings;
@@ -86,8 +78,7 @@ struct CefBrowserCreateParams {
   // ProcessManager::CreateBackgroundHost. Currently used with the alloy
   // runtime only.
   const extensions::Extension* extension = nullptr;
-  extensions::mojom::ViewType extension_host_type =
-      extensions::mojom::ViewType::kInvalid;
+  extensions::ViewType extension_host_type = extensions::VIEW_TYPE_INVALID;
 };
 
 // Base class for CefBrowserHost implementations. Includes functionality that is
@@ -109,11 +100,6 @@ class CefBrowserHostBase : public CefBrowserHost,
     virtual ~Observer() {}
   };
 
-  // Create a new CefBrowserHost instance of the current runtime type with
-  // owned WebContents.
-  static CefRefPtr<CefBrowserHostBase> Create(
-      CefBrowserCreateParams& create_params);
-
   // Returns the browser associated with the specified RenderViewHost.
   static CefRefPtr<CefBrowserHostBase> GetBrowserForHost(
       const content::RenderViewHost* host);
@@ -141,10 +127,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   // Called on the UI thread after the associated WebContents is created.
   virtual void InitializeBrowser();
 
-  // Called on the UI thread when the OS window hosting the browser is
-  // destroyed.
-  virtual void WindowDestroyed() = 0;
-
   // Called on the UI thread after the associated WebContents is destroyed.
   // Also called from CefBrowserInfoManager::DestroyAllBrowsers if the browser
   // was not properly shut down.
@@ -154,7 +136,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   CefRefPtr<CefBrowser> GetBrowser() override;
   CefRefPtr<CefClient> GetClient() override;
   CefRefPtr<CefRequestContext> GetRequestContext() override;
-  bool HasView() override;
   void StartDownload(const CefString& url) override;
   void DownloadImage(const CefString& image_url,
                      bool is_favicon,
@@ -172,12 +153,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   void SendMouseWheelEvent(const CefMouseEvent& event,
                            int deltaX,
                            int deltaY) override;
-  bool SendDevToolsMessage(const void* message, size_t message_size) override;
-  int ExecuteDevToolsMethod(int message_id,
-                            const CefString& method,
-                            CefRefPtr<CefDictionaryValue> params) override;
-  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
-      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   void GetNavigationEntries(CefRefPtr<CefNavigationEntryVisitor> visitor,
                             bool current_only) override;
   CefRefPtr<CefNavigationEntry> GetVisibleNavigationEntry() override;
@@ -246,11 +221,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   CefRefPtr<CefRequestContextImpl> request_context() const {
     return request_context_;
   }
-  bool is_views_hosted() const { return is_views_hosted_; }
-  SkColor GetBackgroundColor() const;
-
-  // Returns true if windowless rendering is enabled.
-  virtual bool IsWindowless() const;
 
   // Accessors that must be called on the UI thread.
   content::WebContents* GetWebContents() const;
@@ -262,21 +232,7 @@ class CefBrowserHostBase : public CefBrowserHost,
     return contents_delegate_.get();
   }
 
-#if defined(TOOLKIT_VIEWS)
-  // Returns the Widget owner for the browser window. Only used with windowed
-  // rendering.
-  views::Widget* GetWindowWidget() const;
-
-  // Returns the BrowserView associated with this browser. Only used with Views-
-  // based browsers.
-  CefRefPtr<CefBrowserView> GetBrowserView() const;
-#endif
-
  protected:
-  bool EnsureDevToolsManager();
-  void InitializeDevToolsRegistrationOnUIThread(
-      CefRefPtr<CefRegistration> registration);
-
   // Called from LoadMainFrameURL to perform the actual navigation.
   virtual bool Navigate(const content::OpenURLParams& params);
 
@@ -286,7 +242,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate_;
   scoped_refptr<CefBrowserInfo> browser_info_;
   CefRefPtr<CefRequestContextImpl> request_context_;
-  const bool is_views_hosted_;
 
   // Only accessed on the UI thread.
   std::unique_ptr<CefBrowserContentsDelegate> contents_delegate_;
@@ -305,9 +260,6 @@ class CefBrowserHostBase : public CefBrowserHost,
   bool is_fullscreen_ = false;
   CefRefPtr<CefFrameHostImpl> focused_frame_;
 
-  // Used for creating and managing DevTools instances.
-  std::unique_ptr<CefDevToolsManager> devtools_manager_;
-
  private:
   IMPLEMENT_REFCOUNTING(CefBrowserHostBase);
   DISALLOW_COPY_AND_ASSIGN(CefBrowserHostBase);

libcef/browser/browser_host_create.cc

@@ -27,11 +27,6 @@ class CreateBrowserHelper {
         extra_info_(extra_info),
         request_context_(request_context) {}
 
-  void Run() {
-    CefBrowserHost::CreateBrowserSync(window_info_, client_, url_, settings_,
-                                      extra_info_, request_context_);
-  }
-
   CefWindowInfo window_info_;
   CefRefPtr<CefClient> client_;
   CefString url_;
@@ -76,25 +71,19 @@ bool CefBrowserHost::CreateBrowser(
                   "reduced performance or runtime errors.";
   }
 
-  if (!request_context) {
-    request_context = CefRequestContext::GetGlobalContext();
-  }
-
-  auto helper = std::make_unique<CreateBrowserHelper>(
+  // Create the browser on the UI thread.
+  CreateBrowserHelper* helper = new CreateBrowserHelper(
       windowInfo, client, url, settings, extra_info, request_context);
-
-  auto request_context_impl =
-      static_cast<CefRequestContextImpl*>(request_context.get());
-
-  // Wait for the browser context to be initialized before creating the browser.
-  request_context_impl->ExecuteWhenBrowserContextInitialized(base::BindOnce(
-      [](std::unique_ptr<CreateBrowserHelper> helper) {
-        // Always execute asynchronously to avoid potential issues if we're
-        // being called synchronously during app initialization.
-        CEF_POST_TASK(CEF_UIT, base::BindOnce(&CreateBrowserHelper::Run,
-                                              std::move(helper)));
-      },
-      std::move(helper)));
+  CEF_POST_TASK(CEF_UIT, base::BindOnce(
+                             [](CreateBrowserHelper* helper) {
+                               CefBrowserHost::CreateBrowserSync(
+                                   helper->window_info_, helper->client_,
+                                   helper->url_, helper->settings_,
+                                   helper->extra_info_,
+                                   helper->request_context_);
+                               delete helper;
+                             },
+                             helper));
 
   return true;
 }
@@ -119,14 +108,9 @@ CefRefPtr<CefBrowser> CefBrowserHost::CreateBrowserSync(
     return nullptr;
   }
 
-  if (!request_context) {
-    request_context = CefRequestContext::GetGlobalContext();
-  }
-
-  // Verify that the browser context is valid.
-  auto request_context_impl =
-      static_cast<CefRequestContextImpl*>(request_context.get());
-  if (!request_context_impl->VerifyBrowserContext()) {
+  // Verify that this method is being called on the UI thread.
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    NOTREACHED() << "called on invalid thread";
     return nullptr;
   }
 
@@ -140,17 +124,16 @@ CefRefPtr<CefBrowser> CefBrowserHost::CreateBrowserSync(
   CefBrowserCreateParams create_params;
   create_params.window_info.reset(new CefWindowInfo(windowInfo));
   create_params.client = client;
-  create_params.url = url;
+  create_params.url = GURL(url.ToString());
+  if (!url.empty() && !create_params.url.is_valid() &&
+      !create_params.url.has_scheme()) {
+    std::string new_url = std::string("http://") + url.ToString();
+    create_params.url = GURL(new_url);
+  }
   create_params.settings = settings;
   create_params.extra_info = extra_info;
   create_params.request_context = request_context;
 
-  return CefBrowserHostBase::Create(create_params);
-}
-
-// static
-CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::Create(
-    CefBrowserCreateParams& create_params) {
   if (cef::IsChromeRuntimeEnabled()) {
     auto browser = ChromeBrowserHostImpl::Create(create_params);
     return browser.get();

libcef/browser/browser_info_manager.cc

@@ -181,11 +181,8 @@ bool CefBrowserInfoManager::CanCreateWindow(
   if (allow) {
     CefBrowserCreateParams create_params;
 
-    if (browser->HasView()) {
-      create_params.popup_with_views_hosted_opener = true;
-    } else {
+    if (!browser->HasView())
       create_params.window_info = std::move(window_info);
-    }
 
     create_params.settings = pending_popup->settings;
     create_params.client = pending_popup->client;
@@ -425,8 +422,6 @@ void CefBrowserInfoManager::RenderProcessHostDestroyed(
     content::RenderProcessHost* host) {
   CEF_REQUIRE_UIT();
 
-  host->RemoveObserver(this);
-
   const int render_process_id = host->GetID();
   DCHECK_GT(render_process_id, 0);
 

libcef/browser/browser_platform_delegate.cc

@@ -76,7 +76,7 @@ void CefBrowserPlatformDelegate::BrowserCreated(CefBrowserHostBase* browser) {
 void CefBrowserPlatformDelegate::CreateExtensionHost(
     const extensions::Extension* extension,
     const GURL& url,
-    extensions::mojom::ViewType host_type) {
+    extensions::ViewType host_type) {
   NOTREACHED();
 }
 
@@ -112,7 +112,7 @@ CefWindowHandle CefBrowserPlatformDelegate::GetHostWindowHandle() const {
   return kNullWindowHandle;
 }
 
-#if defined(TOOLKIT_VIEWS)
+#if defined(USE_AURA)
 views::Widget* CefBrowserPlatformDelegate::GetWindowWidget() const {
   NOTREACHED();
   return nullptr;
@@ -122,7 +122,7 @@ CefRefPtr<CefBrowserView> CefBrowserPlatformDelegate::GetBrowserView() const {
   NOTREACHED();
   return nullptr;
 }
-#endif  // defined(TOOLKIT_VIEWS)
+#endif
 
 void CefBrowserPlatformDelegate::PopupWebContentsCreated(
     const CefBrowserSettings& settings,
@@ -318,7 +318,7 @@ void CefBrowserPlatformDelegate::StartDragging(
 }
 
 void CefBrowserPlatformDelegate::UpdateDragCursor(
-    ui::mojom::DragOperation operation) {
+    blink::DragOperation operation) {
   NOTREACHED();
 }
 

libcef/browser/browser_platform_delegate.h

@@ -15,11 +15,10 @@
 #include "include/views/cef_browser_view.h"
 
 #include "base/callback_forward.h"
-#include "extensions/common/mojom/view_type.mojom-forward.h"
+#include "extensions/common/view_type.h"
 #include "third_party/blink/public/common/page/drag_operation.h"
 #include "third_party/blink/public/mojom/page/drag.mojom-forward.h"
 #include "third_party/skia/include/core/SkColor.h"
-#include "ui/base/dragdrop/mojom/drag_drop_types.mojom-forward.h"
 #include "ui/base/window_open_disposition.h"
 
 class GURL;
@@ -57,7 +56,7 @@ class Size;
 class Vector2d;
 }  // namespace gfx
 
-#if defined(TOOLKIT_VIEWS)
+#if defined(USE_AURA)
 namespace views {
 class Widget;
 }
@@ -134,7 +133,7 @@ class CefBrowserPlatformDelegate {
   // Called from AlloyBrowserHostImpl::Create.
   virtual void CreateExtensionHost(const extensions::Extension* extension,
                                    const GURL& url,
-                                   extensions::mojom::ViewType host_type);
+                                   extensions::ViewType host_type);
 
   // Returns the current extension host.
   virtual extensions::ExtensionHost* GetExtensionHost() const;
@@ -168,7 +167,7 @@ class CefBrowserPlatformDelegate {
   // the client, which may be NULL. May be called on multiple threads.
   virtual CefWindowHandle GetHostWindowHandle() const;
 
-#if defined(TOOLKIT_VIEWS)
+#if defined(USE_AURA)
   // Returns the Widget owner for the browser window. Only used with windowed
   // rendering.
   virtual views::Widget* GetWindowWidget() const;
@@ -328,7 +327,7 @@ class CefBrowserPlatformDelegate {
       const gfx::Vector2d& image_offset,
       const blink::mojom::DragEventSourceInfo& event_info,
       content::RenderWidgetHostImpl* source_rwh);
-  virtual void UpdateDragCursor(ui::mojom::DragOperation operation);
+  virtual void UpdateDragCursor(blink::DragOperation operation);
   virtual void DragSourceEndedAt(int x, int y, cef_drag_operations_mask_t op);
   virtual void DragSourceSystemDragEnded();
   virtual void AccessibilityEventReceived(

libcef/browser/browser_platform_delegate_create.cc

@@ -29,8 +29,7 @@
 #error A delegate implementation is not available for your platform.
 #endif
 
-#if defined(TOOLKIT_VIEWS)
-#include "libcef/browser/chrome/views/browser_platform_delegate_chrome_views.h"
+#if defined(USE_AURA)
 #include "libcef/browser/views/browser_platform_delegate_views.h"
 #endif
 
@@ -83,14 +82,6 @@ std::unique_ptr<CefBrowserPlatformDelegate> CefBrowserPlatformDelegate::Create(
     // CefWindowInfo is not used in this case.
     std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate =
         CreateNativeDelegate(CefWindowInfo(), background_color);
-#if defined(TOOLKIT_VIEWS)
-    if (create_params.browser_view ||
-        create_params.popup_with_views_hosted_opener) {
-      return std::make_unique<CefBrowserPlatformDelegateChromeViews>(
-          std::move(native_delegate),
-          static_cast<CefBrowserViewImpl*>(create_params.browser_view.get()));
-    }
-#endif
     return std::make_unique<CefBrowserPlatformDelegateChrome>(
         std::move(native_delegate));
   }
@@ -115,14 +106,14 @@ std::unique_ptr<CefBrowserPlatformDelegate> CefBrowserPlatformDelegate::Create(
     }
     return std::move(native_delegate);
   } else if (create_params.extension_host_type ==
-             extensions::mojom::ViewType::kExtensionBackgroundPage) {
+             extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     // Creating a background extension host without a window.
     std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate =
         CreateNativeDelegate(CefWindowInfo(), background_color);
     return std::make_unique<CefBrowserPlatformDelegateBackground>(
         std::move(native_delegate));
   }
-#if defined(TOOLKIT_VIEWS)
+#if defined(USE_AURA)
   else {
     // CefWindowInfo is not used in this case.
     std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate =
@@ -131,7 +122,7 @@ std::unique_ptr<CefBrowserPlatformDelegate> CefBrowserPlatformDelegate::Create(
         std::move(native_delegate),
         static_cast<CefBrowserViewImpl*>(create_params.browser_view.get()));
   }
-#endif  // defined(TOOLKIT_VIEWS)
+#endif  // defined(USE_AURA)
 
   NOTREACHED();
   return nullptr;

libcef/browser/chrome/browser_platform_delegate_chrome.cc

@@ -86,11 +86,6 @@ void CefBrowserPlatformDelegateChrome::ViewText(const std::string& text) {
   native_delegate_->ViewText(text);
 }
 
-CefEventHandle CefBrowserPlatformDelegateChrome::GetEventHandle(
-    const content::NativeWebKeyboardEvent& event) const {
-  return native_delegate_->GetEventHandle(event);
-}
-
 CefWindowHandle CefBrowserPlatformDelegateChrome::GetParentWindowHandle()
     const {
   return GetHostWindowHandle();

libcef/browser/chrome/browser_platform_delegate_chrome.h

@@ -36,8 +36,6 @@ class CefBrowserPlatformDelegateChrome
                            int deltaY) override;
   gfx::Point GetScreenPoint(const gfx::Point& view) const override;
   void ViewText(const std::string& text) override;
-  CefEventHandle GetEventHandle(
-      const content::NativeWebKeyboardEvent& event) const override;
 
   // CefBrowserPlatformDelegateNative::WindowlessHandler methods:
   CefWindowHandle GetParentWindowHandle() const override;
@@ -45,7 +43,7 @@ class CefBrowserPlatformDelegateChrome
 
   void set_chrome_browser(Browser* browser);
 
- protected:
+ private:
   std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate_;
 
   Browser* chrome_browser_ = nullptr;

libcef/browser/chrome/chrome_browser_context.cc

@@ -4,14 +4,13 @@
 
 #include "libcef/browser/chrome/chrome_browser_context.h"
 
-#include "libcef/browser/thread_util.h"
+#include "libcef/browser/prefs/browser_prefs.h"
 
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/profiles/off_the_record_profile_impl.h"
+#include "chrome/browser/profiles/profile_manager.h"
 
 ChromeBrowserContext::ChromeBrowserContext(
     const CefRequestContextSettings& settings)
-    : CefBrowserContext(settings), weak_ptr_factory_(this) {}
+    : CefBrowserContext(settings) {}
 
 ChromeBrowserContext::~ChromeBrowserContext() = default;
 
@@ -23,106 +22,19 @@ Profile* ChromeBrowserContext::AsProfile() {
   return profile_;
 }
 
-bool ChromeBrowserContext::IsInitialized() const {
-  CEF_REQUIRE_UIT();
-  return !!profile_;
-}
-
-void ChromeBrowserContext::StoreOrTriggerInitCallback(
-    base::OnceClosure callback) {
-  CEF_REQUIRE_UIT();
-  if (IsInitialized()) {
-    std::move(callback).Run();
-  } else {
-    init_callbacks_.emplace_back(std::move(callback));
-  }
-}
-
-void ChromeBrowserContext::InitializeAsync(base::OnceClosure initialized_cb) {
-  init_callbacks_.emplace_back(std::move(initialized_cb));
-
+void ChromeBrowserContext::Initialize() {
   CefBrowserContext::Initialize();
 
-  if (!cache_path_.empty()) {
-    auto* profile_manager = g_browser_process->profile_manager();
-    const auto& user_data_dir = profile_manager->user_data_dir();
+  // TODO(chrome-runtime): ProfileManager can create new profiles relative to
+  // the user-data-dir, but it should be done asynchronously.
+  // The global ProfileManager instance can be retrieved via
+  // |g_browser_process->profile_manager()|.
+  profile_ = ProfileManager::GetLastUsedProfileAllowedByPolicy();
 
-    if (cache_path_ == user_data_dir) {
-      // Use the default disk-based profile.
-      auto profile = profile_manager->GetPrimaryUserProfile();
-      ProfileCreated(profile, Profile::CreateStatus::CREATE_STATUS_INITIALIZED);
-      return;
-    } else if (cache_path_.DirName() == user_data_dir) {
-      // Create or load a specific disk-based profile. May continue
-      // synchronously or asynchronously.
-      profile_manager->CreateProfileAsync(
-          cache_path_, base::Bind(&ChromeBrowserContext::ProfileCreated,
-                                  weak_ptr_factory_.GetWeakPtr()));
-      return;
-    } else {
-      // All profile directories must be relative to |user_data_dir|.
-      LOG(ERROR) << "Cannot create profile at path "
-                 << cache_path_.AsUTF8Unsafe();
-    }
-  }
-
-  // Default to creating a new/unique OffTheRecord profile.
-  ProfileCreated(nullptr, Profile::CreateStatus::CREATE_STATUS_CANCELED);
+  browser_prefs::SetLanguagePrefs(profile_);
 }
 
 void ChromeBrowserContext::Shutdown() {
   CefBrowserContext::Shutdown();
-  // |g_browser_process| may be nullptr during shutdown.
-  if (should_destroy_ && g_browser_process) {
-    g_browser_process->profile_manager()
-        ->GetPrimaryUserProfile()
-        ->DestroyOffTheRecordProfile(profile_);
-  }
   profile_ = nullptr;
 }
-
-void ChromeBrowserContext::ProfileCreated(Profile* profile,
-                                          Profile::CreateStatus status) {
-  Profile* parent_profile = nullptr;
-  OffTheRecordProfileImpl* otr_profile = nullptr;
-
-  if (status != Profile::CreateStatus::CREATE_STATUS_CREATED &&
-      status != Profile::CreateStatus::CREATE_STATUS_INITIALIZED) {
-    CHECK(!profile);
-    CHECK(!profile_);
-
-    // Creation of a disk-based profile failed for some reason. Create a
-    // new/unique OffTheRecord profile instead.
-    const auto& profile_id = Profile::OTRProfileID::CreateUniqueForCEF();
-    parent_profile =
-        g_browser_process->profile_manager()->GetPrimaryUserProfile();
-    profile_ = parent_profile->GetOffTheRecordProfile(profile_id);
-    otr_profile = static_cast<OffTheRecordProfileImpl*>(profile_);
-    status = Profile::CreateStatus::CREATE_STATUS_INITIALIZED;
-    should_destroy_ = true;
-  } else if (profile && !profile_) {
-    // May be CREATE_STATUS_CREATED or CREATE_STATUS_INITIALIZED since
-    // *CREATED isn't always sent for a disk-based profile that already
-    // exists.
-    profile_ = profile;
-  }
-
-  if (status == Profile::CreateStatus::CREATE_STATUS_INITIALIZED) {
-    CHECK(profile_);
-
-    // Must set |profile_| before Init() calls
-    // ChromeContentBrowserClientCef::ConfigureNetworkContextParams so that
-    // CefBrowserContext::FromBrowserContext can find us.
-    if (otr_profile) {
-      otr_profile->Init();
-      parent_profile->NotifyOffTheRecordProfileCreated(otr_profile);
-    }
-
-    if (!init_callbacks_.empty()) {
-      for (auto& callback : init_callbacks_) {
-        std::move(callback).Run();
-      }
-      init_callbacks_.clear();
-    }
-  }
-}

libcef/browser/chrome/chrome_browser_context.h

@@ -8,36 +8,22 @@
 
 #include "libcef/browser/browser_context.h"
 
-#include "base/memory/weak_ptr.h"
-#include "chrome/browser/profiles/profile_manager.h"
-
 // See CefBrowserContext documentation for usage. Only accessed on the UI thread
 // unless otherwise indicated.
 class ChromeBrowserContext : public CefBrowserContext {
  public:
   explicit ChromeBrowserContext(const CefRequestContextSettings& settings);
 
-  void InitializeAsync(base::OnceClosure initialized_cb);
-
   // CefBrowserContext overrides.
   content::BrowserContext* AsBrowserContext() override;
   Profile* AsProfile() override;
-  bool IsInitialized() const override;
-  void StoreOrTriggerInitCallback(base::OnceClosure callback) override;
+  void Initialize() override;
   void Shutdown() override;
 
  private:
   ~ChromeBrowserContext() override;
 
-  void ProfileCreated(Profile* profile, Profile::CreateStatus status);
-
-  base::OnceClosure initialized_cb_;
   Profile* profile_ = nullptr;
-  bool should_destroy_ = false;
-
-  std::vector<base::OnceClosure> init_callbacks_;
-
-  base::WeakPtrFactory<ChromeBrowserContext> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeBrowserContext);
 };

libcef/browser/chrome/chrome_browser_delegate.cc

@@ -16,7 +16,6 @@
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_tabstrip.h"
 #include "content/public/browser/keyboard_event_processing_result.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 
@@ -66,7 +65,7 @@ void ChromeBrowserDelegate::SetAsDelegate(content::WebContents* web_contents,
           create_params_.request_context);
 
   CreateBrowser(web_contents, create_params_.settings, create_params_.client,
-                std::move(platform_delegate), browser_info, /*opener=*/nullptr,
+                std::move(platform_delegate), browser_info,
                 request_context_impl);
 }
 
@@ -104,28 +103,7 @@ void ChromeBrowserDelegate::WebContentsCreated(
   // We don't officially own |new_contents| until AddNewContents() is called.
   // However, we need to install observers/delegates here.
   CreateBrowser(new_contents, settings, client, std::move(platform_delegate),
-                browser_info, opener, request_context_impl);
-}
-
-void ChromeBrowserDelegate::AddNewContents(
-    content::WebContents* source_contents,
-    std::unique_ptr<content::WebContents> new_contents,
-    const GURL& target_url,
-    WindowOpenDisposition disposition,
-    const gfx::Rect& initial_rect,
-    bool user_gesture,
-    bool* was_blocked) {
-  auto new_browser =
-      ChromeBrowserHostImpl::GetBrowserForContents(new_contents.get());
-  if (new_browser) {
-    // Create a new Browser and give it ownership of the WebContents.
-    new_browser->AddNewContents(std::move(new_contents));
-    return;
-  }
-
-  // Fall back to default behavior from Browser::AddNewContents.
-  chrome::AddWebContents(browser_, source_contents, std::move(new_contents),
-                         target_url, disposition, initial_rect);
+                browser_info, request_context_impl);
 }
 
 content::WebContents* ChromeBrowserDelegate::OpenURLFromTab(
@@ -156,9 +134,9 @@ void ChromeBrowserDelegate::UpdateTargetURL(content::WebContents* source,
 bool ChromeBrowserDelegate::DidAddMessageToConsole(
     content::WebContents* source,
     blink::mojom::ConsoleMessageLevel log_level,
-    const std::u16string& message,
+    const base::string16& message,
     int32_t line_no,
-    const std::u16string& source_id) {
+    const base::string16& source_id) {
   if (auto delegate = GetDelegateForWebContents(source)) {
     return delegate->DidAddMessageToConsole(source, log_level, message, line_no,
                                             source_id);
@@ -217,7 +195,6 @@ void ChromeBrowserDelegate::CreateBrowser(
     CefRefPtr<CefClient> client,
     std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
     scoped_refptr<CefBrowserInfo> browser_info,
-    CefRefPtr<ChromeBrowserHostImpl> opener,
     CefRefPtr<CefRequestContextImpl> request_context_impl) {
   CEF_REQUIRE_UIT();
   DCHECK(web_contents);
@@ -225,9 +202,6 @@ void ChromeBrowserDelegate::CreateBrowser(
   DCHECK(browser_info);
   DCHECK(request_context_impl);
 
-  // If |opener| is non-nullptr it must be a popup window.
-  DCHECK(!opener.get() || browser_info->is_popup());
-
   if (!client) {
     if (auto app = CefAppManager::Get()->GetApplication()) {
       if (auto bph = app->GetBrowserProcessHandler()) {
@@ -252,12 +226,7 @@ void ChromeBrowserDelegate::CreateBrowser(
   CefRefPtr<ChromeBrowserHostImpl> browser_host =
       new ChromeBrowserHostImpl(settings, client, std::move(platform_delegate),
                                 browser_info, request_context_impl);
-  browser_host->Attach(web_contents, opener);
-
-  // The Chrome browser for a popup won't be created until AddNewContents().
-  if (!opener) {
-    browser_host->SetBrowser(browser_);
-  }
+  browser_host->Attach(browser_, web_contents);
 }
 
 CefBrowserContentsDelegate* ChromeBrowserDelegate::GetDelegateForWebContents(
@@ -283,11 +252,6 @@ std::unique_ptr<BrowserDelegate> BrowserDelegate::Create(
       cef_params.get());
   if (params) {
     create_params = params->create_params_;
-
-    // Clear these values so they're not persisted to additional Browsers.
-#if defined(TOOLKIT_VIEWS)
-    params->create_params_.browser_view = nullptr;
-#endif
   }
 
   return std::make_unique<ChromeBrowserDelegate>(browser, create_params);

libcef/browser/chrome/chrome_browser_delegate.h

@@ -55,13 +55,6 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
                           const std::string& frame_name,
                           const GURL& target_url,
                           content::WebContents* new_contents) override;
-  void AddNewContents(content::WebContents* source_contents,
-                      std::unique_ptr<content::WebContents> new_contents,
-                      const GURL& target_url,
-                      WindowOpenDisposition disposition,
-                      const gfx::Rect& initial_rect,
-                      bool user_gesture,
-                      bool* was_blocked) override;
   content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) override;
@@ -70,9 +63,9 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
   void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
   bool DidAddMessageToConsole(content::WebContents* source,
                               blink::mojom::ConsoleMessageLevel log_level,
-                              const std::u16string& message,
+                              const base::string16& message,
                               int32_t line_no,
-                              const std::u16string& source_id) override;
+                              const base::string16& source_id) override;
   void DidNavigateMainFramePostCommit(
       content::WebContents* web_contents) override;
   void EnterFullscreenModeForTab(
@@ -95,7 +88,6 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
       CefRefPtr<CefClient> client,
       std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
       scoped_refptr<CefBrowserInfo> browser_info,
-      CefRefPtr<ChromeBrowserHostImpl> opener,
       CefRefPtr<CefRequestContextImpl> request_context_impl);
 
   CefBrowserContentsDelegate* GetDelegateForWebContents(

libcef/browser/chrome/chrome_browser_host_impl.cc

@@ -7,8 +7,6 @@
 #include "libcef/browser/browser_platform_delegate.h"
 #include "libcef/browser/chrome/browser_platform_delegate_chrome.h"
 #include "libcef/browser/thread_util.h"
-#include "libcef/browser/views/browser_view_impl.h"
-#include "libcef/common/net/url_util.h"
 #include "libcef/features/runtime_checks.h"
 
 #include "base/logging.h"
@@ -22,18 +20,32 @@
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
-
-#if defined(TOOLKIT_VIEWS)
-#include "libcef/browser/chrome/views/chrome_browser_frame.h"
-#include "libcef/browser/chrome/views/chrome_browser_view.h"
-#endif
+#include "url/url_constants.h"
 
 // static
 CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserHostImpl::Create(
     const CefBrowserCreateParams& params) {
-  auto browser = CreateBrowser(params);
+  // Get or create the request context and profile.
+  CefRefPtr<CefRequestContextImpl> request_context_impl =
+      CefRequestContextImpl::GetOrCreateForRequestContext(
+          params.request_context);
+  CHECK(request_context_impl);
+  auto cef_browser_context = request_context_impl->GetBrowserContext();
+  CHECK(cef_browser_context);
+  auto profile = cef_browser_context->AsProfile();
 
-  GURL url = url_util::MakeGURL(params.url, /*fixup=*/true);
+  Browser::CreateParams chrome_params =
+      Browser::CreateParams(profile, /*user_gesture=*/false);
+
+  // Pass |params| to cef::BrowserDelegate::Create from the Browser constructor.
+  chrome_params.cef_params = base::MakeRefCounted<DelegateCreateParams>(params);
+
+  // Create the Browser. This will indirectly create the ChomeBrowserDelegate.
+  // The same params will be used to create a new Browser if the tab is dragged
+  // out of the existing Browser.
+  auto browser = Browser::Create(chrome_params);
+
+  GURL url = params.url;
   if (url.is_empty()) {
     // Chrome will navigate to kChromeUINewTabURL by default. We want to keep
     // the current CEF behavior of not navigating at all. Use a special URL that
@@ -44,8 +56,7 @@ CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserHostImpl::Create(
   // Add a new tab. This will indirectly create a new tab WebContents and
   // call ChromeBrowserDelegate::OnWebContentsCreated to create the associated
   // ChromeBrowserHostImpl.
-  chrome::AddTabAt(browser, url, /*index=*/TabStripModel::kNoTab,
-                   /*foreground=*/true);
+  chrome::AddTabAt(browser, url, /*idx=*/-1, /*foreground=*/true);
 
   // The new tab WebContents.
   auto web_contents = browser->tab_strip_model()->GetActiveWebContents();
@@ -106,34 +117,6 @@ CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserHostImpl::GetBrowserForFrameRoute(
 
 ChromeBrowserHostImpl::~ChromeBrowserHostImpl() = default;
 
-void ChromeBrowserHostImpl::AddNewContents(
-    std::unique_ptr<content::WebContents> contents) {
-  DCHECK(contents);
-  DCHECK(!browser_);
-
-  // We should already be associated with the WebContents.
-  DCHECK_EQ(GetWebContents(), contents.get());
-
-  CefBrowserCreateParams params;
-  params.request_context = request_context();
-#if defined(TOOLKIT_VIEWS)
-  params.browser_view = GetBrowserView();
-#endif
-
-  // Create the new Browser representation.
-  auto browser = CreateBrowser(params);
-
-  // Add the WebContents to the Browser.
-  browser->tab_strip_model()->AddWebContents(
-      std::move(contents), /*index=*/TabStripModel::kNoTab,
-      ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL,
-      TabStripModel::ADD_ACTIVE);
-
-  SetBrowser(browser);
-
-  browser->window()->Show();
-}
-
 void ChromeBrowserHostImpl::OnWebContentsDestroyed(
     content::WebContents* web_contents) {
   platform_delegate_->WebContentsDestroyed(web_contents);
@@ -165,9 +148,8 @@ void ChromeBrowserHostImpl::CloseBrowser(bool force_close) {
 }
 
 bool ChromeBrowserHostImpl::TryCloseBrowser() {
-  // TODO(chrome): Handle the case where the browser may not close immediately.
-  CloseBrowser(true);
-  return true;
+  NOTIMPLEMENTED();
+  return false;
 }
 
 void ChromeBrowserHostImpl::SetFocus(bool focus) {
@@ -186,6 +168,11 @@ CefWindowHandle ChromeBrowserHostImpl::GetOpenerWindowHandle() {
   return kNullWindowHandle;
 }
 
+bool ChromeBrowserHostImpl::HasView() {
+  // TODO(chrome-runtime): Support Views-hosted browsers.
+  return false;
+}
+
 double ChromeBrowserHostImpl::GetZoomLevel() {
   NOTIMPLEMENTED();
   return 0.0;
@@ -258,6 +245,26 @@ bool ChromeBrowserHostImpl::HasDevTools() {
   return false;
 }
 
+bool ChromeBrowserHostImpl::SendDevToolsMessage(const void* message,
+                                                size_t message_size) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+int ChromeBrowserHostImpl::ExecuteDevToolsMethod(
+    int message_id,
+    const CefString& method,
+    CefRefPtr<CefDictionaryValue> params) {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+CefRefPtr<CefRegistration> ChromeBrowserHostImpl::AddDevToolsMessageObserver(
+    CefRefPtr<CefDevToolsMessageObserver> observer) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
 bool ChromeBrowserHostImpl::IsWindowRenderingDisabled() {
   return false;
 }
@@ -391,17 +398,13 @@ bool ChromeBrowserHostImpl::Navigate(const content::OpenURLParams& params) {
   }
 
   if (browser_) {
-    GURL gurl = params.url;
-    if (!url_util::FixupGURL(gurl))
-      return false;
-
     // This is generally equivalent to calling Browser::OpenURL, except:
     // 1. It doesn't trigger a call to CefRequestHandler::OnOpenURLFromTab, and
     // 2. It navigates in this CefBrowserHost's WebContents instead of
     //    (a) creating a new WebContents, or (b) using the Browser's active
     //    WebContents (which may not be the same), and
     // 3. There is no risk of triggering chrome's popup blocker.
-    NavigateParams nav_params(browser_, gurl, params.transition);
+    NavigateParams nav_params(browser_, params.url, params.transition);
     nav_params.FillNavigateParamsFromOpenURLParams(params);
 
     // Always navigate in the current tab.
@@ -429,113 +432,17 @@ ChromeBrowserHostImpl::ChromeBrowserHostImpl(
                          browser_info,
                          request_context) {}
 
-// static
-Browser* ChromeBrowserHostImpl::CreateBrowser(
-    const CefBrowserCreateParams& params) {
-  // Get or create the request context and profile.
-  CefRefPtr<CefRequestContextImpl> request_context_impl =
-      CefRequestContextImpl::GetOrCreateForRequestContext(
-          params.request_context);
-  CHECK(request_context_impl);
-  auto cef_browser_context = request_context_impl->GetBrowserContext();
-  CHECK(cef_browser_context);
-  auto profile = cef_browser_context->AsProfile();
-  CHECK(profile);
-
-  Browser::CreateParams chrome_params =
-      Browser::CreateParams(profile, /*user_gesture=*/false);
-
-  // Pass |params| to cef::BrowserDelegate::Create from the Browser constructor.
-  chrome_params.cef_params = base::MakeRefCounted<DelegateCreateParams>(params);
-
-#if defined(TOOLKIT_VIEWS)
-  // Configure Browser creation to use the existing Views-based
-  // Widget/BrowserFrame (ChromeBrowserFrame) and BrowserView/BrowserWindow
-  // (ChromeBrowserView). See views/chrome_browser_frame.h for related
-  // documentation.
-  ChromeBrowserView* chrome_browser_view = nullptr;
-  if (params.browser_view) {
-    // Don't show most controls.
-    chrome_params.type = Browser::TYPE_POPUP;
-    // Don't show title bar or address.
-    chrome_params.trusted_source = true;
-
-    auto view_impl =
-        static_cast<CefBrowserViewImpl*>(params.browser_view.get());
-
-    chrome_browser_view =
-        static_cast<ChromeBrowserView*>(view_impl->root_view());
-    chrome_params.window = chrome_browser_view;
-
-    auto chrome_widget =
-        static_cast<ChromeBrowserFrame*>(chrome_browser_view->GetWidget());
-    chrome_browser_view->set_frame(chrome_widget);
-  }
-#endif  // defined(TOOLKIT_VIEWS)
-
-  // Create the Browser. This will indirectly create the ChomeBrowserDelegate.
-  // The same params will be used to create a new Browser if the tab is dragged
-  // out of the existing Browser. The returned Browser is owned by the
-  // associated BrowserView.
-  auto browser = Browser::Create(chrome_params);
-
-#if defined(TOOLKIT_VIEWS)
-  if (chrome_browser_view) {
-    // Initialize the BrowserFrame and BrowserView and create the controls that
-    // require access to the Browser.
-    chrome_browser_view->InitBrowser(base::WrapUnique(browser),
-                                     params.browser_view);
-  }
-#endif
-
-  return browser;
-}
-
-void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
-                                   CefRefPtr<ChromeBrowserHostImpl> opener) {
+void ChromeBrowserHostImpl::Attach(Browser* browser,
+                                   content::WebContents* web_contents) {
+  DCHECK(browser);
   DCHECK(web_contents);
 
-  if (opener) {
-    // Give the opener browser's platform delegate an opportunity to modify the
-    // new browser's platform delegate.
-    opener->platform_delegate_->PopupWebContentsCreated(
-        settings_, client_, web_contents, platform_delegate_.get(),
-        /*is_devtools_popup=*/false);
-  }
-
   platform_delegate_->WebContentsCreated(web_contents,
                                          /*own_web_contents=*/false);
+
+  SetBrowser(browser);
   contents_delegate_->ObserveWebContents(web_contents);
-
-  // Associate the platform delegate with this browser.
-  platform_delegate_->BrowserCreated(this);
-
-  // Associate the base class with the WebContents.
   InitializeBrowser();
-
-  // Notify that the browser has been created. These must be delivered in the
-  // expected order.
-
-  // 1. Notify the browser's LifeSpanHandler. This must always be the first
-  // notification for the browser.
-  {
-    // The WebContents won't be added to the Browser's TabStripModel until later
-    // in the current call stack. Block navigation until that time.
-    auto navigation_lock = browser_info_->CreateNavigationLock();
-    OnAfterCreated();
-  }
-
-  // 2. Notify the platform delegate. With Views this will result in a call to
-  // CefBrowserViewDelegate::OnBrowserCreated().
-  platform_delegate_->NotifyBrowserCreated();
-
-  if (opener && opener->platform_delegate_) {
-    // 3. Notify the opener browser's platform delegate. With Views this will
-    // result in a call to CefBrowserViewDelegate::OnPopupBrowserViewCreated().
-    opener->platform_delegate_->PopupBrowserCreated(
-        this,
-        /*is_devtools_popup=*/false);
-  }
 }
 
 void ChromeBrowserHostImpl::SetBrowser(Browser* browser) {
@@ -545,17 +452,19 @@ void ChromeBrowserHostImpl::SetBrowser(Browser* browser) {
       ->set_chrome_browser(browser);
 }
 
-void ChromeBrowserHostImpl::WindowDestroyed() {
+void ChromeBrowserHostImpl::InitializeBrowser() {
   CEF_REQUIRE_UIT();
-#if defined(TOOLKIT_VIEWS)
-  if (browser_ && is_views_hosted_) {
-    auto chrome_browser_view =
-        static_cast<ChromeBrowserView*>(browser_->window());
-    chrome_browser_view->Destroyed();
-  }
-#endif
+  DCHECK(browser_);
 
-  platform_delegate_->CloseHostWindow();
+  // Associate the platform delegate with this browser.
+  platform_delegate_->BrowserCreated(this);
+
+  CefBrowserHostBase::InitializeBrowser();
+
+  // The WebContents won't be added to the Browser's TabStripModel until later
+  // in the current call stack. Block navigation until that time.
+  auto navigation_lock = browser_info_->CreateNavigationLock();
+  OnAfterCreated();
 }
 
 void ChromeBrowserHostImpl::DestroyBrowser() {
@@ -577,8 +486,6 @@ void ChromeBrowserHostImpl::DoCloseBrowser(bool force_close) {
     // Like chrome::CloseTab() but specifying the WebContents.
     const int tab_index = GetCurrentTabIndex();
     if (tab_index != TabStripModel::kNoTab) {
-      // TODO(chrome): Handle the case where this method returns false,
-      // indicating that the contents were not closed immediately.
       browser_->tab_strip_model()->CloseWebContentsAt(
           tab_index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB |
                          TabStripModel::CLOSE_USER_GESTURE);

libcef/browser/chrome/chrome_browser_host_impl.h

@@ -66,6 +66,7 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
   void SetFocus(bool focus) override;
   CefWindowHandle GetWindowHandle() override;
   CefWindowHandle GetOpenerWindowHandle() override;
+  bool HasView() override;
   double GetZoomLevel() override;
   void SetZoomLevel(double zoomLevel) override;
   void RunFileDialog(FileDialogMode mode,
@@ -90,6 +91,12 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
                     const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
+  bool SendDevToolsMessage(const void* message, size_t message_size) override;
+  int ExecuteDevToolsMethod(int message_id,
+                            const CefString& method,
+                            CefRefPtr<CefDictionaryValue> params) override;
+  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
+      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   bool IsWindowRenderingDisabled() override;
   void WasResized() override;
   void WasHidden(bool hidden) override;
@@ -142,25 +149,17 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
       scoped_refptr<CefBrowserInfo> browser_info,
       CefRefPtr<CefRequestContextImpl> request_context);
 
-  // Create a new Browser without initializing the WebContents.
-  static Browser* CreateBrowser(const CefBrowserCreateParams& params);
-
-  // Called from ChromeBrowserDelegate::CreateBrowser when this object is first
+  // Called from ChromeBrowserDelegate::SetAsDelegate when this object is first
   // created. Must be called on the UI thread.
-  void Attach(content::WebContents* web_contents,
-              CefRefPtr<ChromeBrowserHostImpl> opener);
+  void Attach(Browser* browser, content::WebContents* web_contents);
 
-  // Called from ChromeBrowserDelegate::AddNewContents to take ownership of a
-  // popup WebContents.
-  void AddNewContents(std::unique_ptr<content::WebContents> contents);
-
-  // Called when this object changes Browser ownership (e.g. initially created,
-  // dragging between windows, etc). The old Browser, if any, will be cleared
-  // before the new Browser is added. Must be called on the UI thread.
+  // Called from ChromeBrowserDelegate::SetAsDelegate when this object changes
+  // Browser ownership (e.g. dragging between windows). The old Browser will be
+  // cleared before the new Browser is added. Must be called on the UI thread.
   void SetBrowser(Browser* browser);
 
   // CefBrowserHostBase methods:
-  void WindowDestroyed() override;
+  void InitializeBrowser() override;
   void DestroyBrowser() override;
 
   void DoCloseBrowser(bool force_close);

libcef/browser/chrome/chrome_browser_main_extra_parts_cef.cc

@@ -4,12 +4,9 @@
 
 #include "libcef/browser/chrome/chrome_browser_main_extra_parts_cef.h"
 
-#include "libcef/browser/chrome/chrome_context_menu_handler.h"
 #include "libcef/browser/context.h"
-#include "libcef/browser/net/chrome_scheme_handler.h"
 
 #include "base/task/post_task.h"
-#include "base/task/thread_pool.h"
 
 ChromeBrowserMainExtraPartsCef::ChromeBrowserMainExtraPartsCef() = default;
 
@@ -25,16 +22,13 @@ void ChromeBrowserMainExtraPartsCef::PostProfileInit() {
 }
 
 void ChromeBrowserMainExtraPartsCef::PreMainMessageLoopRun() {
-  background_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::BEST_EFFORT,
+  background_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
-  user_visible_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::USER_VISIBLE,
+  user_visible_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::USER_VISIBLE,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
-  user_blocking_task_runner_ = base::ThreadPool::CreateSingleThreadTaskRunner(
-      {base::TaskPriority::USER_BLOCKING,
+  user_blocking_task_runner_ = base::CreateSingleThreadTaskRunner(
+      {base::ThreadPool(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::BLOCK_SHUTDOWN, base::MayBlock()});
-
-  scheme::RegisterWebUIControllerFactory();
-  context_menu::RegisterMenuCreatedCallback();
 }

libcef/browser/chrome/chrome_content_browser_client_cef.cc

@@ -7,17 +7,12 @@
 
 #include "libcef/browser/browser_info_manager.h"
 #include "libcef/browser/browser_message_filter.h"
-#include "libcef/browser/chrome/chrome_browser_host_impl.h"
 #include "libcef/browser/chrome/chrome_browser_main_extra_parts_cef.h"
-#include "libcef/browser/context.h"
-#include "libcef/browser/net/chrome_scheme_handler.h"
 #include "libcef/browser/net/throttle_handler.h"
 #include "libcef/browser/net_service/cookie_manager_impl.h"
 #include "libcef/browser/net_service/login_delegate.h"
 #include "libcef/browser/net_service/proxy_url_loader_factory.h"
 #include "libcef/browser/net_service/resource_request_handler_wrapper.h"
-#include "libcef/browser/prefs/browser_prefs.h"
-#include "libcef/browser/prefs/renderer_prefs.h"
 #include "libcef/common/app_manager.h"
 #include "libcef/common/cef_switches.h"
 #include "libcef/common/command_line_impl.h"
@@ -29,11 +24,7 @@
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/render_widget_host.h"
-#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/content_switches.h"
-#include "third_party/blink/public/common/web_preferences/web_preferences.h"
 #include "third_party/blink/public/mojom/loader/resource_load_info.mojom-shared.h"
 
 namespace {
@@ -41,15 +32,13 @@ namespace {
 void HandleExternalProtocolHelper(
     ChromeContentBrowserClientCef* self,
     content::WebContents::OnceGetter web_contents_getter,
-    int frame_tree_node_id,
     content::NavigationUIData* navigation_data,
     const network::ResourceRequest& resource_request) {
   // Match the logic of the original call in
   // NavigationURLLoaderImpl::PrepareForNonInterceptedRequest.
   self->HandleExternalProtocol(
       resource_request.url, std::move(web_contents_getter),
-      content::ChildProcessHost::kInvalidUniqueID, frame_tree_node_id,
-      navigation_data,
+      content::ChildProcessHost::kInvalidUniqueID, navigation_data,
       resource_request.resource_type ==
           static_cast<int>(blink::mojom::ResourceType::kMainFrame),
       static_cast<ui::PageTransition>(resource_request.transition_type),
@@ -92,16 +81,6 @@ void ChromeContentBrowserClientCef::AppendExtraCommandLineSwitches(
 
   const base::CommandLine* browser_cmd = base::CommandLine::ForCurrentProcess();
 
-  {
-    // Propagate the following switches to all command lines (along with any
-    // associated values) if present in the browser command line.
-    static const char* const kSwitchNames[] = {
-        switches::kUserAgentProductAndVersion,
-    };
-    command_line->CopySwitchesFrom(*browser_cmd, kSwitchNames,
-                                   base::size(kSwitchNames));
-  }
-
   const std::string& process_type =
       command_line->GetSwitchValueASCII(switches::kProcessType);
   if (process_type == switches::kRendererProcess) {
@@ -168,33 +147,6 @@ bool ChromeContentBrowserClientCef::CanCreateWindow(
       user_gesture, opener_suppressed, no_javascript_access);
 }
 
-void ChromeContentBrowserClientCef::OverrideWebkitPrefs(
-    content::WebContents* web_contents,
-    blink::web_pref::WebPreferences* prefs) {
-  renderer_prefs::SetDefaultPrefs(*prefs);
-
-  ChromeContentBrowserClient::OverrideWebkitPrefs(web_contents, prefs);
-
-  auto browser = ChromeBrowserHostImpl::GetBrowserForContents(web_contents);
-  if (browser) {
-    renderer_prefs::SetCefPrefs(browser->settings(), *prefs);
-
-    // Set the background color for the WebView.
-    prefs->base_background_color = browser->GetBackgroundColor();
-  } else {
-    // We don't know for sure that the browser will be windowless but assume
-    // that the global windowless state is likely to be accurate.
-    prefs->base_background_color =
-        CefContext::Get()->GetBackgroundColor(nullptr, STATE_DEFAULT);
-  }
-
-  auto rvh = web_contents->GetRenderViewHost();
-  if (rvh->GetWidget()->GetView()) {
-    rvh->GetWidget()->GetView()->SetBackgroundColor(
-        prefs->base_background_color);
-  }
-}
-
 bool ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
     content::BrowserContext* browser_context,
     content::RenderFrameHost* frame,
@@ -218,13 +170,6 @@ bool ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
     return use_proxy;
   }
 
-  // Don't intercept requests for Profiles that were not created by CEF.
-  // For example, the User Manager profile created via
-  // profiles::CreateSystemProfileForUserManager.
-  auto profile = Profile::FromBrowserContext(browser_context);
-  if (!CefBrowserContext::FromProfile(profile))
-    return false;
-
   auto request_handler = net_service::CreateInterceptedRequestHandler(
       browser_context, frame, render_process_id,
       type == URLLoaderFactoryType::kNavigation,
@@ -240,7 +185,6 @@ bool ChromeContentBrowserClientCef::HandleExternalProtocol(
     const GURL& url,
     content::WebContents::OnceGetter web_contents_getter,
     int child_id,
-    int frame_tree_node_id,
     content::NavigationUIData* navigation_data,
     bool is_main_frame,
     ui::PageTransition page_transition,
@@ -258,9 +202,9 @@ bool ChromeContentBrowserClientCef::HandleExternalProtocol(
   // HandleExternalProtocolHelper. Forward to the chrome layer for default
   // handling.
   return ChromeContentBrowserClient::HandleExternalProtocol(
-      url, std::move(web_contents_getter), child_id, frame_tree_node_id,
-      navigation_data, is_main_frame, page_transition, has_user_gesture,
-      initiating_origin, nullptr);
+      url, std::move(web_contents_getter), child_id, navigation_data,
+      is_main_frame, page_transition, has_user_gesture, initiating_origin,
+      nullptr);
 }
 
 bool ChromeContentBrowserClientCef::HandleExternalProtocol(
@@ -276,8 +220,7 @@ bool ChromeContentBrowserClientCef::HandleExternalProtocol(
   auto request_handler = net_service::CreateInterceptedRequestHandler(
       web_contents_getter, frame_tree_node_id, resource_request,
       base::Bind(HandleExternalProtocolHelper, base::Unretained(this),
-                 web_contents_getter, frame_tree_node_id, navigation_data,
-                 resource_request));
+                 web_contents_getter, navigation_data, resource_request));
 
   net_service::ProxyURLLoaderFactory::CreateProxy(
       web_contents_getter, std::move(receiver), std::move(request_handler));
@@ -298,8 +241,7 @@ void ChromeContentBrowserClientCef::ConfigureNetworkContextParams(
     bool in_memory,
     const base::FilePath& relative_partition_path,
     network::mojom::NetworkContextParams* network_context_params,
-    cert_verifier::mojom::CertVerifierCreationParams*
-        cert_verifier_creation_params) {
+    network::mojom::CertVerifierCreationParams* cert_verifier_creation_params) {
   ChromeContentBrowserClient::ConfigureNetworkContextParams(
       context, in_memory, relative_partition_path, network_context_params,
       cert_verifier_creation_params);
@@ -307,18 +249,7 @@ void ChromeContentBrowserClientCef::ConfigureNetworkContextParams(
   auto cef_context = CefBrowserContext::FromBrowserContext(context);
   network_context_params->cookieable_schemes =
       cef_context ? cef_context->GetCookieableSchemes()
-                  : CefBrowserContext::GetGlobalCookieableSchemes();
-
-  // Prefer the CEF settings configuration, if specified, instead of the
-  // kAcceptLanguages preference which is controlled by the
-  // chrome://settings/languages configuration.
-  const std::string& accept_language_list =
-      browser_prefs::GetAcceptLanguageList(cef_context, /*browser=*/nullptr,
-                                           /*expand=*/true);
-  if (!accept_language_list.empty() &&
-      accept_language_list != network_context_params->accept_language) {
-    network_context_params->accept_language = accept_language_list;
-  }
+                  : CefCookieManagerImpl::GetGlobalCookieableSchemes();
 }
 
 std::unique_ptr<content::LoginDelegate>
@@ -345,18 +276,6 @@ ChromeContentBrowserClientCef::CreateLoginDelegate(
       response_headers, first_auth_attempt, std::move(auth_required_callback));
 }
 
-void ChromeContentBrowserClientCef::BrowserURLHandlerCreated(
-    content::BrowserURLHandler* handler) {
-  // Register the Chrome handlers first for proper URL rewriting.
-  ChromeContentBrowserClient::BrowserURLHandlerCreated(handler);
-  scheme::BrowserURLHandlerCreated(handler);
-}
-
-bool ChromeContentBrowserClientCef::IsWebUIAllowedToMakeNetworkRequests(
-    const url::Origin& origin) {
-  return scheme::IsWebUIAllowedToMakeNetworkRequests(origin);
-}
-
 CefRefPtr<CefRequestContextImpl>
 ChromeContentBrowserClientCef::request_context() const {
   return browser_main_parts_->request_context();

libcef/browser/chrome/chrome_content_browser_client_cef.h

@@ -40,8 +40,6 @@ class ChromeContentBrowserClientCef : public ChromeContentBrowserClient {
                        bool user_gesture,
                        bool opener_suppressed,
                        bool* no_javascript_access) override;
-  void OverrideWebkitPrefs(content::WebContents* web_contents,
-                           blink::web_pref::WebPreferences* prefs) override;
   bool WillCreateURLLoaderFactory(
       content::BrowserContext* browser_context,
       content::RenderFrameHost* frame,
@@ -60,7 +58,6 @@ class ChromeContentBrowserClientCef : public ChromeContentBrowserClient {
       const GURL& url,
       content::WebContents::OnceGetter web_contents_getter,
       int child_id,
-      int frame_tree_node_id,
       content::NavigationUIData* navigation_data,
       bool is_main_frame,
       ui::PageTransition page_transition,
@@ -83,8 +80,8 @@ class ChromeContentBrowserClientCef : public ChromeContentBrowserClient {
       bool in_memory,
       const base::FilePath& relative_partition_path,
       network::mojom::NetworkContextParams* network_context_params,
-      cert_verifier::mojom::CertVerifierCreationParams*
-          cert_verifier_creation_params) override;
+      network::mojom::CertVerifierCreationParams* cert_verifier_creation_params)
+      override;
   std::unique_ptr<content::LoginDelegate> CreateLoginDelegate(
       const net::AuthChallengeInfo& auth_info,
       content::WebContents* web_contents,
@@ -94,8 +91,6 @@ class ChromeContentBrowserClientCef : public ChromeContentBrowserClient {
       scoped_refptr<net::HttpResponseHeaders> response_headers,
       bool first_auth_attempt,
       LoginAuthRequiredCallback auth_required_callback) override;
-  void BrowserURLHandlerCreated(content::BrowserURLHandler* handler) override;
-  bool IsWebUIAllowedToMakeNetworkRequests(const url::Origin& origin) override;
 
   CefRefPtr<CefRequestContextImpl> request_context() const;
 

libcef/browser/chrome/chrome_context_menu_handler.cc

@@ -1,207 +0,0 @@
-// Copyright (c) 2021 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.
-
-#include "libcef/browser/chrome/chrome_context_menu_handler.h"
-
-#include "libcef/browser/browser_host_base.h"
-#include "libcef/browser/context_menu_params_impl.h"
-#include "libcef/browser/simple_menu_model_impl.h"
-
-#include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
-
-namespace context_menu {
-
-namespace {
-
-// Lifespan is controlled by RenderViewContextMenu.
-class CefContextMenuObserver : public RenderViewContextMenuObserver,
-                               public CefSimpleMenuModelImpl::StateDelegate {
- public:
-  CefContextMenuObserver(RenderViewContextMenu* context_menu,
-                         CefRefPtr<CefBrowserHostBase> browser,
-                         CefRefPtr<CefContextMenuHandler> handler)
-      : context_menu_(context_menu), browser_(browser), handler_(handler) {}
-
-  // RenderViewContextMenuObserver methods:
-
-  void InitMenu(const content::ContextMenuParams& params) override {
-    params_ = new CefContextMenuParamsImpl(
-        const_cast<content::ContextMenuParams*>(&context_menu_->params()));
-    model_ = new CefSimpleMenuModelImpl(
-        const_cast<ui::SimpleMenuModel*>(&context_menu_->menu_model()),
-        context_menu_, this, /*is_owned=*/false, /*is_popup=*/false);
-
-    handler_->OnBeforeContextMenu(browser_, GetFrame(), params_, model_);
-  }
-
-  bool IsCommandIdSupported(int command_id) override {
-    // Always claim support for the reserved user ID range.
-    if (command_id >= MENU_ID_USER_FIRST && command_id <= MENU_ID_USER_LAST)
-      return true;
-
-    // Also claim support in specific cases where an ItemInfo exists.
-    return GetItemInfo(command_id) != nullptr;
-  }
-
-  // Only called if IsCommandIdSupported() returns true.
-  bool IsCommandIdEnabled(int command_id) override {
-    // Always return true to use the SimpleMenuModel state.
-    return true;
-  }
-
-  // Only called if IsCommandIdSupported() returns true.
-  bool IsCommandIdChecked(int command_id) override {
-    auto* info = GetItemInfo(command_id);
-    return info ? info->checked : false;
-  }
-
-  // Only called if IsCommandIdSupported() returns true.
-  bool GetAccelerator(int command_id, ui::Accelerator* accel) override {
-    auto* info = GetItemInfo(command_id);
-    if (info && info->accel) {
-      *accel = *info->accel;
-      return true;
-    }
-    return false;
-  }
-
-  void CommandWillBeExecuted(int command_id) override {
-    if (handler_->OnContextMenuCommand(browser_, GetFrame(), params_,
-                                       command_id, EVENTFLAG_NONE)) {
-      // Create an ItemInfo so that we get the ExecuteCommand() callback
-      // instead of the default handler.
-      GetOrCreateItemInfo(command_id);
-    }
-  }
-
-  // Only called if IsCommandIdSupported() returns true.
-  void ExecuteCommand(int command_id) override {
-    auto* info = GetItemInfo(command_id);
-    if (info) {
-      // In case it was added in CommandWillBeExecuted().
-      MaybeDeleteItemInfo(command_id, info);
-    }
-  }
-
-  void OnMenuClosed() override {
-    handler_->OnContextMenuDismissed(browser_, GetFrame());
-    model_->Detach();
-
-    // Clear stored state because this object won't be deleted until a new
-    // context menu is created or the associated browser is destroyed.
-    browser_ = nullptr;
-    handler_ = nullptr;
-    params_ = nullptr;
-    model_ = nullptr;
-    iteminfomap_.clear();
-  }
-
-  // CefSimpleMenuModelImpl::StateDelegate methods:
-
-  void SetChecked(int command_id, bool checked) override {
-    // No-op if already at the default state.
-    if (!checked && !GetItemInfo(command_id))
-      return;
-
-    auto* info = GetOrCreateItemInfo(command_id);
-    info->checked = checked;
-    if (!checked)
-      MaybeDeleteItemInfo(command_id, info);
-  }
-
-  void SetAccelerator(int command_id,
-                      base::Optional<ui::Accelerator> accel) override {
-    // No-op if already at the default state.
-    if (!accel && !GetItemInfo(command_id))
-      return;
-
-    auto* info = GetOrCreateItemInfo(command_id);
-    info->accel = accel;
-    if (!accel)
-      MaybeDeleteItemInfo(command_id, info);
-  }
-
- private:
-  struct ItemInfo {
-    ItemInfo() {}
-
-    bool checked = false;
-    base::Optional<ui::Accelerator> accel;
-  };
-
-  ItemInfo* GetItemInfo(int command_id) {
-    auto it = iteminfomap_.find(command_id);
-    if (it != iteminfomap_.end()) {
-      return &it->second;
-    }
-    return nullptr;
-  }
-
-  ItemInfo* GetOrCreateItemInfo(int command_id) {
-    if (auto info = GetItemInfo(command_id))
-      return info;
-
-    auto result = iteminfomap_.insert(std::make_pair(command_id, ItemInfo()));
-    return &result.first->second;
-  }
-
-  void MaybeDeleteItemInfo(int command_id, ItemInfo* info) {
-    // Remove if all info has reverted to the default state.
-    if (!info->checked && !info->accel) {
-      auto it = iteminfomap_.find(command_id);
-      iteminfomap_.erase(it);
-    }
-  }
-
-  CefRefPtr<CefFrame> GetFrame() const {
-    CefRefPtr<CefFrame> frame;
-
-    // May return nullptr if the frame is destroyed while the menu is pending.
-    auto* rfh = context_menu_->GetRenderFrameHost();
-    if (rfh) {
-      frame = browser_->GetFrameForHost(rfh);
-    }
-    if (!frame) {
-      frame = browser_->GetMainFrame();
-    }
-    return frame;
-  }
-
-  RenderViewContextMenu* const context_menu_;
-  CefRefPtr<CefBrowserHostBase> browser_;
-  CefRefPtr<CefContextMenuHandler> handler_;
-  CefRefPtr<CefContextMenuParams> params_;
-  CefRefPtr<CefSimpleMenuModelImpl> model_;
-
-  // Map of command_id to ItemInfo.
-  using ItemInfoMap = std::map<int, ItemInfo>;
-  ItemInfoMap iteminfomap_;
-
-  DISALLOW_COPY_AND_ASSIGN(CefContextMenuObserver);
-};
-
-std::unique_ptr<RenderViewContextMenuObserver> MenuCreatedCallback(
-    RenderViewContextMenu* context_menu) {
-  auto browser = CefBrowserHostBase::GetBrowserForContents(
-      context_menu->source_web_contents());
-  if (browser) {
-    if (auto client = browser->GetClient()) {
-      if (auto handler = client->GetContextMenuHandler()) {
-        return std::make_unique<CefContextMenuObserver>(context_menu, browser,
-                                                        handler);
-      }
-    }
-  }
-
-  return nullptr;
-}
-
-}  // namespace
-
-void RegisterMenuCreatedCallback() {
-  RenderViewContextMenu::RegisterMenuCreatedCallback(
-      base::BindRepeating(&MenuCreatedCallback));
-}
-
-}  // namespace context_menu

libcef/browser/chrome/chrome_context_menu_handler.h

@@ -1,16 +0,0 @@
-// Copyright (c) 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_CHROME_CONTEXT_MENU_HANDLER_H_
-#define CEF_LIBCEF_BROWSER_CHROME_CHROME_CONTEXT_MENU_HANDLER_H_
-#pragma once
-
-namespace context_menu {
-
-// Register the context menu created callback.
-void RegisterMenuCreatedCallback();
-
-}  // namespace context_menu
-
-#endif  // CEF_LIBCEF_BROWSER_CHROME_CHROME_CONTEXT_MENU_HANDLER_H_

libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc

@@ -1,153 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/chrome/views/browser_platform_delegate_chrome_views.h"
-
-#include "include/views/cef_window.h"
-
-#include "chrome/browser/ui/browser.h"
-#include "ui/views/widget/widget.h"
-
-namespace {
-
-// Default popup window delegate implementation.
-class PopupWindowDelegate : public CefWindowDelegate {
- public:
-  explicit PopupWindowDelegate(CefRefPtr<CefBrowserView> browser_view)
-      : browser_view_(browser_view) {}
-
-  void OnWindowCreated(CefRefPtr<CefWindow> window) override {
-    window->AddChildView(browser_view_);
-    window->Show();
-    browser_view_->RequestFocus();
-  }
-
-  void OnWindowDestroyed(CefRefPtr<CefWindow> window) override {
-    browser_view_ = nullptr;
-  }
-
-  bool CanClose(CefRefPtr<CefWindow> window) override {
-    CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-    if (browser)
-      return browser->GetHost()->TryCloseBrowser();
-    return true;
-  }
-
- private:
-  CefRefPtr<CefBrowserView> browser_view_;
-
-  IMPLEMENT_REFCOUNTING(PopupWindowDelegate);
-  DISALLOW_COPY_AND_ASSIGN(PopupWindowDelegate);
-};
-
-}  // namespace
-
-CefBrowserPlatformDelegateChromeViews::CefBrowserPlatformDelegateChromeViews(
-    std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
-    CefRefPtr<CefBrowserViewImpl> browser_view)
-    : CefBrowserPlatformDelegateChrome(std::move(native_delegate)) {
-  if (browser_view)
-    SetBrowserView(browser_view);
-}
-
-void CefBrowserPlatformDelegateChromeViews::SetBrowserView(
-    CefRefPtr<CefBrowserViewImpl> browser_view) {
-  DCHECK(!browser_view_);
-  DCHECK(browser_view);
-  browser_view_ = browser_view;
-}
-
-void CefBrowserPlatformDelegateChromeViews::WebContentsCreated(
-    content::WebContents* web_contents,
-    bool owned) {
-  CefBrowserPlatformDelegateChrome::WebContentsCreated(web_contents, owned);
-  browser_view_->WebContentsCreated(web_contents);
-}
-
-void CefBrowserPlatformDelegateChromeViews::BrowserCreated(
-    CefBrowserHostBase* browser) {
-  CefBrowserPlatformDelegateChrome::BrowserCreated(browser);
-  browser_view_->BrowserCreated(browser, base::RepeatingClosure());
-}
-
-void CefBrowserPlatformDelegateChromeViews::NotifyBrowserCreated() {
-  if (browser_view_->delegate())
-    browser_view_->delegate()->OnBrowserCreated(browser_view_, browser_);
-}
-
-void CefBrowserPlatformDelegateChromeViews::NotifyBrowserDestroyed() {
-  if (browser_view_->delegate())
-    browser_view_->delegate()->OnBrowserDestroyed(browser_view_, browser_);
-}
-
-void CefBrowserPlatformDelegateChromeViews::BrowserDestroyed(
-    CefBrowserHostBase* browser) {
-  CefBrowserPlatformDelegateChrome::BrowserDestroyed(browser);
-  browser_view_->BrowserDestroyed(browser);
-}
-
-void CefBrowserPlatformDelegateChromeViews::CloseHostWindow() {
-  views::Widget* widget = GetWindowWidget();
-  if (widget && !widget->IsClosed())
-    widget->Close();
-}
-
-views::Widget* CefBrowserPlatformDelegateChromeViews::GetWindowWidget() const {
-  if (browser_view_->root_view())
-    return browser_view_->root_view()->GetWidget();
-  return nullptr;
-}
-
-CefRefPtr<CefBrowserView>
-CefBrowserPlatformDelegateChromeViews::GetBrowserView() const {
-  return browser_view_.get();
-}
-
-void CefBrowserPlatformDelegateChromeViews::PopupWebContentsCreated(
-    const CefBrowserSettings& settings,
-    CefRefPtr<CefClient> client,
-    content::WebContents* new_web_contents,
-    CefBrowserPlatformDelegate* new_platform_delegate,
-    bool is_devtools) {
-  DCHECK(new_platform_delegate->IsViewsHosted());
-  auto* new_platform_delegate_impl =
-      static_cast<CefBrowserPlatformDelegateChromeViews*>(
-          new_platform_delegate);
-
-  CefRefPtr<CefBrowserViewDelegate> new_delegate;
-  if (browser_view_->delegate()) {
-    new_delegate = browser_view_->delegate()->GetDelegateForPopupBrowserView(
-        browser_view_.get(), settings, client, is_devtools);
-  }
-
-  // Create a new BrowserView for the popup.
-  CefRefPtr<CefBrowserViewImpl> new_browser_view =
-      CefBrowserViewImpl::CreateForPopup(settings, new_delegate);
-
-  // Associate the PlatformDelegate with the new BrowserView.
-  new_platform_delegate_impl->SetBrowserView(new_browser_view);
-}
-
-void CefBrowserPlatformDelegateChromeViews::PopupBrowserCreated(
-    CefBrowserHostBase* new_browser,
-    bool is_devtools) {
-  CefRefPtr<CefBrowserView> new_browser_view =
-      CefBrowserView::GetForBrowser(new_browser);
-  DCHECK(new_browser_view);
-
-  bool popup_handled = false;
-  if (browser_view_->delegate()) {
-    popup_handled = browser_view_->delegate()->OnPopupBrowserViewCreated(
-        browser_view_.get(), new_browser_view.get(), is_devtools);
-  }
-
-  if (!popup_handled) {
-    CefWindow::CreateTopLevelWindow(
-        new PopupWindowDelegate(new_browser_view.get()));
-  }
-}
-
-bool CefBrowserPlatformDelegateChromeViews::IsViewsHosted() const {
-  return true;
-}

libcef/browser/chrome/views/browser_platform_delegate_chrome_views.h

@@ -1,45 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_VIEWS_BROWSER_PLATFORM_DELEGATE_CHROME_VIEWS_H_
-#define CEF_LIBCEF_BROWSER_CHROME_VIEWS_BROWSER_PLATFORM_DELEGATE_CHROME_VIEWS_H_
-
-#include "libcef/browser/chrome/browser_platform_delegate_chrome.h"
-#include "libcef/browser/views/browser_view_impl.h"
-
-// Implementation of Chrome-based browser functionality.
-class CefBrowserPlatformDelegateChromeViews
-    : public CefBrowserPlatformDelegateChrome {
- public:
-  explicit CefBrowserPlatformDelegateChromeViews(
-      std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
-      CefRefPtr<CefBrowserViewImpl> browser_view);
-
-  // CefBrowserPlatformDelegate overrides.
-  void WebContentsCreated(content::WebContents* web_contents,
-                          bool owned) override;
-  void BrowserCreated(CefBrowserHostBase* browser) override;
-  void NotifyBrowserCreated() override;
-  void NotifyBrowserDestroyed() override;
-  void BrowserDestroyed(CefBrowserHostBase* browser) override;
-  void CloseHostWindow() override;
-  views::Widget* GetWindowWidget() const override;
-  CefRefPtr<CefBrowserView> GetBrowserView() const override;
-  void PopupWebContentsCreated(
-      const CefBrowserSettings& settings,
-      CefRefPtr<CefClient> client,
-      content::WebContents* new_web_contents,
-      CefBrowserPlatformDelegate* new_platform_delegate,
-      bool is_devtools) override;
-  void PopupBrowserCreated(CefBrowserHostBase* new_browser,
-                           bool is_devtools) override;
-  bool IsViewsHosted() const override;
-
- private:
-  void SetBrowserView(CefRefPtr<CefBrowserViewImpl> browser_view);
-
-  CefRefPtr<CefBrowserViewImpl> browser_view_;
-};
-
-#endif  // CEF_LIBCEF_BROWSER_CHROME_VIEWS_BROWSER_PLATFORM_DELEGATE_CHROME_VIEWS_H_

libcef/browser/chrome/views/chrome_browser_frame.cc

@@ -1,35 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/chrome/views/chrome_browser_frame.h"
-
-#include "chrome/browser/themes/theme_service.h"
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/views/frame/browser_view.h"
-
-void ChromeBrowserFrame::Init(BrowserView* browser_view,
-                              std::unique_ptr<Browser> browser) {
-  DCHECK(browser_view);
-
-  DCHECK(!browser_);
-  browser_ = browser.get();
-  DCHECK(browser_);
-
-  // Initialize BrowserFrame state.
-  InitBrowserView(browser_view);
-
-  // Initialize BrowserView state.
-  browser_view->InitBrowser(std::move(browser));
-}
-
-views::internal::RootView* ChromeBrowserFrame::CreateRootView() {
-  // Bypass the BrowserFrame implementation.
-  return views::Widget::CreateRootView();
-}
-
-std::unique_ptr<views::NonClientFrameView>
-ChromeBrowserFrame::CreateNonClientFrameView() {
-  // Bypass the BrowserFrame implementation.
-  return views::Widget::CreateNonClientFrameView();
-}

libcef/browser/chrome/views/chrome_browser_frame.h

@@ -1,109 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_FRAME_H_
-#define CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_FRAME_H_
-#pragma once
-
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/views/frame/browser_frame.h"
-
-// An overview of the Chrome Browser object model is provided below. Object
-// creation normally begins with a call to Browser::Create(CreateParams) which
-// then creates the necessary Browser view, window and frame objects. CEF has
-// modified the default object creation model are described below to better
-// integrate with the existing CEF Views APIs.
-//
-// OVERVIEW
-//
-// Browser and BrowserWindow are the primary Chrome objects. Browser provides
-// the concrete state and mutation methods while BrowserWindow is an interface
-// implemented by the platform-specific "view" of the Browser window.
-//
-// Browser:
-// - Creates a BrowserView (aka BrowserWindow) and BrowserFrame (aka Widget) via
-//   a call to BrowserWindow::CreateBrowserWindow() in the Browser constructor.
-//   - An existing BrowserWindow can alternately be specified via the
-//     Browser::CreateParams::window parameter.
-// - Owned by the BrowserView after creation.
-//
-// The Chrome Views implementation uses BrowserView to represent the browser
-// client area and BrowserFrame (plus helpers) to represent the non-client
-// window frame.
-//
-// BrowserView:
-// - Extends BrowserWindow, views::ClientView, views::WidgetDelegate.
-// - Owns the Browser.
-// - References the BrowserFrame.
-// - Passed to Widget::Init() via Widget::InitParams::delegate to receive
-//   WidgetDelegate callbacks.
-// - Extended by CEF as ChromeBrowserView.
-// BrowserFrame:
-// - Extends Widget (aka views::internal::NativeWidgetDelegate).
-// - References the BrowserView.
-// - Creates/owns a DesktopBrowserFrameAura (aka NativeBrowserFrame) via
-//   BrowserFrame::InitBrowserFrame().
-// - Extended by CEF as ChromeBrowserFrame.
-//
-// Chrome custom window/frame handling is implemented using platform-specific
-// objects.
-//
-// DesktopBrowserFrameAura:
-// - Extends NativeBrowserFrame, DesktopNativeWidgetAura.
-// - Acts as a helper for BrowserFrame.
-// - Creates/references a BrowserDesktopWindowTreeHostWin via
-//   DesktopBrowserFrameAura::InitNativeWidget().
-// BrowserDesktopWindowTreeHostWin (for Windows):
-// - Extends DesktopWindowTreeHost.
-// - References DesktopBrowserFrameAura, BrowserView, BrowserFrame.
-// - Passed to Widget::Init() via Widget::InitParams::desktop_window_tree_host.
-//
-// CEF MODIFICATIONS
-//
-// The CEF Views integration uses an alternative approach of creating the
-// ChromeBrowserFrame in CefWindowView::CreateWidget() and the
-// ChromeBrowserView in CefBrowserViewImpl::CreateRootView().
-// The object associations described above are then configured via
-// ChromeBrowserView::AddedToWidget() and ChromeBrowserHostImpl::Create()
-// after the BrowserView is added to the Widget. The Chromium code has been
-// patched to allow later initialization of the Browser, BrowserFrame and
-// BrowserView members to support this model.
-//
-// CEF does not use Chrome's NativeBrowserFrame (aka DesktopBrowserFrameAura),
-// BrowserNonClientFrameView or BrowserRootView objects (all normally created by
-// BrowserFrame during Widget initialization). Consequently
-// |BrowserFrame::native_browser_frame_| and |BrowserFrame::browser_frame_view_|
-// (sometimes retrieved via BrowserFrame::GetFrameView) will be nullptr and the
-// Chromium code has been patched to add the necessary null checks.
-//
-// CEF does not pass ChromeBrowserView as the WidgetDelegate when the Widget is
-// initialized in CefWindowView::CreateWidget(). Some of the WidgetDelegate
-// callbacks may need to be routed from CefWindowView to ChromeBrowserView in
-// the future.
-//
-// See the chrome_runtime_views.patch file for the complete set of related
-// modifications.
-
-class BrowserView;
-
-// Widget for a Views-hosted Chrome browser. Created in
-// CefWindowView::CreateWidget() when the Chrome runtime is enabled.
-class ChromeBrowserFrame : public BrowserFrame {
- public:
-  ChromeBrowserFrame() {}
-  ChromeBrowserFrame(const ChromeBrowserFrame&) = delete;
-  ChromeBrowserFrame& operator=(const ChromeBrowserFrame&) = delete;
-
-  void Init(BrowserView* browser_view, std::unique_ptr<Browser> browser);
-
-  // views::Widget methods:
-  views::internal::RootView* CreateRootView() override;
-  std::unique_ptr<views::NonClientFrameView> CreateNonClientFrameView()
-      override;
-
- private:
-  Browser* browser_ = nullptr;
-};
-
-#endif  // CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_FRAME_H_

libcef/browser/chrome/views/chrome_browser_view.cc

@@ -1,98 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/chrome/views/chrome_browser_view.h"
-
-#include "libcef/browser/chrome/views/chrome_browser_frame.h"
-#include "libcef/browser/views/browser_view_impl.h"
-
-ChromeBrowserView::ChromeBrowserView(CefBrowserViewDelegate* cef_delegate,
-                                     Delegate* browser_view_delegate)
-    : ParentClass(cef_delegate), browser_view_delegate_(browser_view_delegate) {
-  DCHECK(browser_view_delegate_);
-}
-
-void ChromeBrowserView::InitBrowser(std::unique_ptr<Browser> browser,
-                                    CefRefPtr<CefBrowserView> browser_view) {
-  DCHECK(!browser_);
-  DCHECK(!web_view_);
-
-  browser_ = browser.get();
-  DCHECK(browser_);
-
-  // Initialize the BrowserFrame and BrowserView.
-  auto chrome_widget = static_cast<ChromeBrowserFrame*>(GetWidget());
-  chrome_widget->Init(this, std::move(browser));
-
-  // Retrieve the views::WebView that was created by the above initializations.
-  auto view_impl = static_cast<CefBrowserViewImpl*>(browser_view.get());
-  web_view_ = view_impl->web_view();
-  DCHECK(web_view_);
-
-  ParentClass::AddedToWidget();
-}
-
-void ChromeBrowserView::Destroyed() {
-  DCHECK(!destroyed_);
-  destroyed_ = true;
-  browser_ = nullptr;
-  web_view_ = nullptr;
-}
-
-void ChromeBrowserView::ViewHierarchyChanged(
-    const views::ViewHierarchyChangedDetails& details) {
-  ParentClass::ViewHierarchyChanged(details);
-  if (details.is_add && details.child == this) {
-    gfx::Size size = GetPreferredSize();
-    if (size.IsEmpty()) {
-      // No size was provided for this View. Size it to the parent by default
-      // or, depending on the Layout, the browser may be initially 0x0 size and
-      // will not display until the parent is next resized (resulting in a call
-      // to WebView::OnBoundsChanged). For example, this can happen when adding
-      // this View to a CefWindow with FillLayout and then calling
-      // CefWindow::Show() without first resizing the CefWindow.
-      size = details.parent->GetPreferredSize();
-      if (!size.IsEmpty())
-        SetSize(size);
-    }
-  }
-}
-
-void ChromeBrowserView::AddedToWidget() {
-  // Results in a call to InitBrowser which calls ParentClass::AddedToWidget.
-  browser_view_delegate_->OnBrowserViewAdded();
-}
-
-void ChromeBrowserView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
-  ParentClass::OnBoundsChanged(previous_bounds);
-  browser_view_delegate_->OnBoundsChanged();
-}
-
-ToolbarView* ChromeBrowserView::OverrideCreateToolbar(
-    Browser* browser,
-    BrowserView* browser_view) {
-  if (cef_delegate()) {
-    auto toolbar_type = cef_delegate()->GetChromeToolbarType();
-    base::Optional<ToolbarView::DisplayMode> display_mode;
-    switch (toolbar_type) {
-      case CEF_CTT_NORMAL:
-        display_mode = ToolbarView::DisplayMode::NORMAL;
-        break;
-      case CEF_CTT_LOCATION:
-        display_mode = ToolbarView::DisplayMode::LOCATION;
-        break;
-      default:
-        break;
-    }
-    if (display_mode) {
-      cef_toolbar_ = CefToolbarViewImpl::Create(nullptr, browser, browser_view,
-                                                display_mode);
-      // Ownership will be taken by BrowserView.
-      view_util::PassOwnership(cef_toolbar_).release();
-      return cef_toolbar_->root_view();
-    }
-  }
-
-  return nullptr;
-}

libcef/browser/chrome/views/chrome_browser_view.h

@@ -1,66 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_VIEW_H_
-#define CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_VIEW_H_
-#pragma once
-
-#include "include/views/cef_browser_view.h"
-#include "include/views/cef_browser_view_delegate.h"
-#include "libcef/browser/chrome/views/toolbar_view_impl.h"
-#include "libcef/browser/views/browser_view_view.h"
-#include "libcef/browser/views/view_view.h"
-
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/views/frame/browser_view.h"
-
-namespace views {
-class WebView;
-}  // namespace views
-
-// A variant of CefBrowserViewView that extends BrowserView instead of
-// views::WebView. See chrome_browser_frame.h for related documentation.
-class ChromeBrowserView
-    : public CefViewView<BrowserView, CefBrowserViewDelegate> {
- public:
-  using ParentClass = CefViewView<BrowserView, CefBrowserViewDelegate>;
-  using Delegate = CefBrowserViewView::Delegate;
-
-  // |cef_delegate| may be nullptr.
-  // |browser_view_delegate| must be non-nullptr.
-  ChromeBrowserView(CefBrowserViewDelegate* cef_delegate,
-                    Delegate* browser_view_delegate);
-
-  // Called by ChromeBrowserHostImpl.
-  void InitBrowser(std::unique_ptr<Browser> browser,
-                   CefRefPtr<CefBrowserView> browser_view);
-  void Destroyed();
-
-  // View methods:
-  void ViewHierarchyChanged(
-      const views::ViewHierarchyChangedDetails& details) override;
-  void AddedToWidget() override;
-  void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
-
-  // BrowserView methods:
-  ToolbarView* OverrideCreateToolbar(Browser* browser,
-                                     BrowserView* browser_view) override;
-
-  CefRefPtr<CefToolbarViewImpl> cef_toolbar() const { return cef_toolbar_; }
-
- private:
-  // Not owned by this object.
-  Delegate* browser_view_delegate_;
-
-  Browser* browser_ = nullptr;
-  views::WebView* web_view_ = nullptr;
-
-  bool destroyed_ = false;
-
-  CefRefPtr<CefToolbarViewImpl> cef_toolbar_;
-
-  DISALLOW_COPY_AND_ASSIGN(ChromeBrowserView);
-};
-
-#endif  // CEF_LIBCEF_BROWSER_CHROME_VIEWS_CHROME_BROWSER_VIEW_H_

libcef/browser/chrome/views/toolbar_view_impl.cc

@@ -1,40 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/chrome/views/toolbar_view_impl.h"
-
-// static
-CefRefPtr<CefToolbarViewImpl> CefToolbarViewImpl::Create(
-    CefRefPtr<CefViewDelegate> delegate,
-    Browser* browser,
-    BrowserView* browser_view,
-    base::Optional<ToolbarView::DisplayMode> display_mode) {
-  CEF_REQUIRE_UIT_RETURN(nullptr);
-  CefRefPtr<CefToolbarViewImpl> view =
-      new CefToolbarViewImpl(delegate, browser, browser_view, display_mode);
-  view->Initialize();
-  return view;
-}
-
-// static
-const char* const CefToolbarViewImpl::kTypeString = "ToolbarView";
-
-CefToolbarViewImpl::CefToolbarViewImpl(
-    CefRefPtr<CefViewDelegate> delegate,
-    Browser* browser,
-    BrowserView* browser_view,
-    base::Optional<ToolbarView::DisplayMode> display_mode)
-    : ParentClass(delegate),
-      browser_(browser),
-      browser_view_(browser_view),
-      display_mode_(display_mode) {}
-
-CefToolbarViewView* CefToolbarViewImpl::CreateRootView() {
-  return new CefToolbarViewView(delegate(), browser_, browser_view_,
-                                display_mode_);
-}
-
-void CefToolbarViewImpl::InitializeRootView() {
-  static_cast<CefToolbarViewView*>(root_view())->Initialize();
-}

libcef/browser/chrome/views/toolbar_view_impl.h

@@ -1,55 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_VIEWS_TOOLBAR_VIEW_IMPL_H_
-#define CEF_LIBCEF_BROWSER_CHROME_VIEWS_TOOLBAR_VIEW_IMPL_H_
-#pragma once
-
-#include "include/views/cef_view_delegate.h"
-
-#include "libcef/browser/chrome/views/toolbar_view_view.h"
-#include "libcef/browser/views/view_impl.h"
-
-class Browser;
-class BrowserView;
-
-class CefToolbarViewImpl
-    : public CefViewImpl<CefToolbarViewView, CefView, CefViewDelegate> {
- public:
-  typedef CefViewImpl<CefToolbarViewView, CefView, CefViewDelegate> ParentClass;
-
-  // Create a new CefToolbarViewImpl instance. |delegate| may be nullptr.
-  static CefRefPtr<CefToolbarViewImpl> Create(
-      CefRefPtr<CefViewDelegate> delegate,
-      Browser* browser,
-      BrowserView* browser_view,
-      base::Optional<ToolbarView::DisplayMode> display_mode);
-
-  static const char* const kTypeString;
-
-  // CefViewAdapter methods:
-  std::string GetDebugType() override { return kTypeString; }
-
- private:
-  // Create a new implementation object.
-  // Always call Initialize() after creation.
-  // |delegate| may be nullptr.
-  CefToolbarViewImpl(CefRefPtr<CefViewDelegate> delegate,
-                     Browser* browser,
-                     BrowserView* browser_view,
-                     base::Optional<ToolbarView::DisplayMode> display_mode);
-
-  // CefViewImpl methods:
-  CefToolbarViewView* CreateRootView() override;
-  void InitializeRootView() override;
-
-  Browser* const browser_;
-  BrowserView* const browser_view_;
-  base::Optional<ToolbarView::DisplayMode> const display_mode_;
-
-  IMPLEMENT_REFCOUNTING_DELETE_ON_UIT(CefToolbarViewImpl);
-  DISALLOW_COPY_AND_ASSIGN(CefToolbarViewImpl);
-};
-
-#endif  // CEF_LIBCEF_BROWSER_VIEWS_SCROLL_VIEW_IMPL_H_

libcef/browser/chrome/views/toolbar_view_view.cc

@@ -1,11 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/chrome/views/toolbar_view_view.h"
-
-CefToolbarViewView::CefToolbarViewView(CefViewDelegate* cef_delegate,
-                                       Browser* browser,
-                                       BrowserView* browser_view,
-                                       base::Optional<DisplayMode> display_mode)
-    : ParentClass(cef_delegate, browser, browser_view, display_mode) {}

libcef/browser/chrome/views/toolbar_view_view.h

@@ -1,27 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_CHROME_VIEWS_TOOLBAR_VIEW_VIEW_H_
-#define CEF_LIBCEF_BROWSER_CHROME_VIEWS_TOOLBAR_VIEW_VIEW_H_
-#pragma once
-
-#include "libcef/browser/views/view_view.h"
-
-#include "chrome/browser/ui/views/toolbar/toolbar_view.h"
-
-class CefToolbarViewView : public CefViewView<ToolbarView, CefViewDelegate> {
- public:
-  typedef CefViewView<ToolbarView, CefViewDelegate> ParentClass;
-
-  // |cef_delegate| may be nullptr.
-  explicit CefToolbarViewView(CefViewDelegate* cef_delegate,
-                              Browser* browser,
-                              BrowserView* browser_view,
-                              base::Optional<DisplayMode> display_mode);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CefToolbarViewView);
-};
-
-#endif  // CEF_LIBCEF_BROWSER_CHROME_VIEWS_TOOLBAR_VIEW_VIEW_H_

libcef/browser/context.cc

@@ -5,7 +5,6 @@
 #include "libcef/browser/context.h"
 
 #include "libcef/browser/browser_info_manager.h"
-#include "libcef/browser/request_context_impl.h"
 #include "libcef/browser/thread_util.h"
 #include "libcef/browser/trace_subscriber.h"
 #include "libcef/common/cef_switches.h"
@@ -435,11 +434,8 @@ void CefContext::PopulateGlobalRequestContextSettings(
   settings->ignore_certificate_errors =
       settings_.ignore_certificate_errors ||
       command_line->HasSwitch(switches::kIgnoreCertificateErrors);
-
-  CefString(&settings->cookieable_schemes_list) =
-      CefString(&settings_.cookieable_schemes_list);
-  settings->cookieable_schemes_exclude_defaults =
-      settings_.cookieable_schemes_exclude_defaults;
+  CefString(&settings->accept_language_list) =
+      CefString(&settings_.accept_language_list);
 }
 
 void CefContext::NormalizeRequestContextSettings(
@@ -447,6 +443,12 @@ void CefContext::NormalizeRequestContextSettings(
   // The |root_cache_path| value was already normalized in Initialize.
   const base::FilePath& root_cache_path = CefString(&settings_.root_cache_path);
   NormalizeCachePathAndSet(settings->cache_path, root_cache_path);
+
+  if (settings->accept_language_list.length == 0) {
+    // Use the global language list setting.
+    CefString(&settings->accept_language_list) =
+        CefString(&settings_.accept_language_list);
+  }
 }
 
 void CefContext::AddObserver(Observer* observer) {
@@ -467,19 +469,12 @@ bool CefContext::HasObserver(Observer* observer) const {
 void CefContext::OnContextInitialized() {
   CEF_REQUIRE_UIT();
 
+  // Notify the handler.
   if (application_) {
-    // Notify the handler after the global browser context has initialized.
-    CefRefPtr<CefRequestContext> request_context =
-        CefRequestContext::GetGlobalContext();
-    auto impl = static_cast<CefRequestContextImpl*>(request_context.get());
-    impl->ExecuteWhenBrowserContextInitialized(base::BindOnce(
-        [](CefRefPtr<CefApp> app) {
-          CefRefPtr<CefBrowserProcessHandler> handler =
-              app->GetBrowserProcessHandler();
-          if (handler)
-            handler->OnContextInitialized();
-        },
-        application_));
+    CefRefPtr<CefBrowserProcessHandler> handler =
+        application_->GetBrowserProcessHandler();
+    if (handler)
+      handler->OnContextInitialized();
   }
 }
 

libcef/browser/context_menu_params_impl.cc

@@ -5,7 +5,6 @@
 #include "libcef/browser/context_menu_params_impl.h"
 
 #include "base/logging.h"
-#include "third_party/blink/public/mojom/context_menu/context_menu.mojom.h"
 
 CefContextMenuParamsImpl::CefContextMenuParamsImpl(
     content::ContextMenuParams* value)
@@ -39,7 +38,7 @@ CefContextMenuParamsImpl::TypeFlags CefContextMenuParamsImpl::GetTypeFlags() {
     type_flags |= CM_TYPEFLAG_FRAME;
   if (!params.link_url.is_empty())
     type_flags |= CM_TYPEFLAG_LINK;
-  if (params.media_type != blink::mojom::ContextMenuDataMediaType::kNone)
+  if (params.media_type != blink::ContextMenuDataMediaType::kNone)
     type_flags |= CM_TYPEFLAG_MEDIA;
   if (!params.selection_text.empty())
     type_flags |= CM_TYPEFLAG_SELECTION;
@@ -119,7 +118,7 @@ bool CefContextMenuParamsImpl::GetDictionarySuggestions(
   if (const_value().dictionary_suggestions.empty())
     return false;
 
-  std::vector<std::u16string>::const_iterator it =
+  std::vector<base::string16>::const_iterator it =
       const_value().dictionary_suggestions.begin();
   for (; it != const_value().dictionary_suggestions.end(); ++it)
     suggestions.push_back(*it);
@@ -147,3 +146,8 @@ bool CefContextMenuParamsImpl::IsCustomMenu() {
   CEF_VALUE_VERIFY_RETURN(false, false);
   return !const_value().custom_items.empty();
 }
+
+bool CefContextMenuParamsImpl::IsPepperMenu() {
+  CEF_VALUE_VERIFY_RETURN(false, false);
+  return const_value().custom_context.is_pepper_menu;
+}

libcef/browser/context_menu_params_impl.h

@@ -38,6 +38,7 @@ class CefContextMenuParamsImpl
   bool IsSpellCheckEnabled() override;
   EditStateFlags GetEditStateFlags() override;
   bool IsCustomMenu() override;
+  bool IsPepperMenu() override;
 
   DISALLOW_COPY_AND_ASSIGN(CefContextMenuParamsImpl);
 };

libcef/browser/devtools/devtools_controller.cc

@@ -91,7 +91,7 @@ void CefDevToolsController::RemoveObserver(Observer* observer) {
 void CefDevToolsController::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host,
     base::span<const uint8_t> message) {
-  if (observers_.empty())
+  if (!observers_.might_have_observers())
     return;
 
   base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),

libcef/browser/devtools/devtools_file_manager.cc

@@ -15,7 +15,6 @@
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/post_task.h"
-#include "base/task/thread_pool.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/util/values/values_util.h"
 #include "base/values.h"
@@ -45,8 +44,8 @@ CefDevToolsFileManager::CefDevToolsFileManager(
     PrefService* prefs)
     : browser_impl_(browser_impl),
       prefs_(prefs),
-      file_task_runner_(
-          base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()})),
+      file_task_runner_(base::CreateSequencedTaskRunner(
+          {base::ThreadPool(), base::MayBlock()})),
       weak_factory_(this) {}
 
 void CefDevToolsFileManager::SaveToFile(const std::string& url,

libcef/browser/devtools/devtools_frontend.cc

@@ -251,7 +251,7 @@ CefDevToolsFrontend* CefDevToolsFrontend::Show(
   }
 
   CefBrowserCreateParams create_params;
-  if (!inspected_browser->is_views_hosted())
+  if (!inspected_browser->IsViewsHosted())
     create_params.window_info.reset(new CefWindowInfo(windowInfo));
   create_params.client = client;
   create_params.settings = new_settings;
@@ -338,8 +338,7 @@ void CefDevToolsFrontend::ReadyToCommitNavigation(
   content::DevToolsFrontendHost::SetupExtensionsAPI(frame, script);
 }
 
-void CefDevToolsFrontend::DocumentAvailableInMainFrame(
-    content::RenderFrameHost* render_frame_host) {
+void CefDevToolsFrontend::DocumentAvailableInMainFrame() {
   // Don't call AttachClient multiple times for the same DevToolsAgentHost.
   // Otherwise it will call AgentHostClosed which closes the DevTools window.
   // This may happen in cases where the DevTools content fails to load.
@@ -391,7 +390,8 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
         this, base::as_bytes(base::make_span(protocol_message)));
   } else if (method == "loadCompleted") {
     web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
-        u"DevToolsAPI.setUseSoftMenu(true);", base::NullCallback());
+        base::ASCIIToUTF16("DevToolsAPI.setUseSoftMenu(true);"),
+        base::NullCallback());
   } else if (method == "loadNetworkResource" && params->GetSize() == 3) {
     // TODO(pfeldman): handle some of the embedder messages in content.
     std::string url;
@@ -461,7 +461,7 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
       SendMessageAck(request_id, &response);
       return;
     } else {
-      auto* partition = content::BrowserContext::GetStoragePartitionForUrl(
+      auto* partition = content::BrowserContext::GetStoragePartitionForSite(
           web_contents()->GetBrowserContext(), gurl);
       url_loader_factory = partition->GetURLLoaderFactoryForBrowserProcess();
     }
@@ -493,7 +493,8 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
     update.Get()->RemoveWithoutPathExpansion(name, nullptr);
   } else if (method == "requestFileSystems") {
     web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
-        u"DevToolsAPI.fileSystemsLoaded([]);", base::NullCallback());
+        base::ASCIIToUTF16("DevToolsAPI.fileSystemsLoaded([]);"),
+        base::NullCallback());
   } else if (method == "reattach") {
     if (!agent_host_)
       return;
@@ -532,11 +533,6 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
 void CefDevToolsFrontend::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host,
     base::span<const uint8_t> message) {
-  if (!frontend_browser_->GetWebContents() ||
-      frontend_browser_->GetWebContents()->IsBeingDestroyed()) {
-    return;
-  }
-
   base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),
                                 message.size());
   if (ProtocolLoggingEnabled()) {
@@ -551,7 +547,7 @@ void CefDevToolsFrontend::DispatchProtocolMessage(
     std::string param;
     base::EscapeJSONString(str_message, true, &param);
     std::string code = "DevToolsAPI.dispatchMessage(" + param + ");";
-    std::u16string javascript = base::UTF8ToUTF16(code);
+    base::string16 javascript = base::UTF8ToUTF16(code);
     web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
         javascript, base::NullCallback());
     return;
@@ -565,7 +561,7 @@ void CefDevToolsFrontend::DispatchProtocolMessage(
                            &param);
     std::string code = "DevToolsAPI.dispatchMessageChunk(" + param + "," +
                        std::to_string(pos ? 0 : total_size) + ");";
-    std::u16string javascript = base::UTF8ToUTF16(code);
+    base::string16 javascript = base::UTF8ToUTF16(code);
     web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
         javascript, base::NullCallback());
   }

libcef/browser/devtools/devtools_frontend.h

@@ -76,8 +76,7 @@ class CefDevToolsFrontend : public content::WebContentsObserver,
   // WebContentsObserver overrides
   void ReadyToCommitNavigation(
       content::NavigationHandle* navigation_handle) override;
-  void DocumentAvailableInMainFrame(
-      content::RenderFrameHost* render_frame_host) override;
+  void DocumentAvailableInMainFrame() override;
   void WebContentsDestroyed() override;
 
   void SendMessageAck(int request_id, const base::Value* arg1);

libcef/browser/devtools/devtools_manager.cc

@@ -6,7 +6,6 @@
 
 #include "libcef/browser/devtools/devtools_controller.h"
 #include "libcef/browser/devtools/devtools_frontend.h"
-#include "libcef/features/runtime.h"
 
 #include "content/public/browser/web_contents.h"
 
@@ -32,7 +31,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
     controller_->RemoveObserver(this);
   }
 
-  void Initialize(CefBrowserHostBase* browser,
+  void Initialize(AlloyBrowserHostImpl* browser,
                   base::WeakPtr<CefDevToolsController> controller) {
     CEF_REQUIRE_UIT();
     DCHECK(browser && controller);
@@ -84,7 +83,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
 
   CefRefPtr<CefDevToolsMessageObserver> observer_;
 
-  CefBrowserHostBase* browser_ = nullptr;
+  AlloyBrowserHostImpl* browser_ = nullptr;
   base::WeakPtr<CefDevToolsController> controller_;
 
   IMPLEMENT_REFCOUNTING_DELETE_ON_UIT(CefDevToolsRegistrationImpl);
@@ -93,7 +92,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
 
 }  // namespace
 
-CefDevToolsManager::CefDevToolsManager(CefBrowserHostBase* inspected_browser)
+CefDevToolsManager::CefDevToolsManager(AlloyBrowserHostImpl* inspected_browser)
     : inspected_browser_(inspected_browser), weak_ptr_factory_(this) {
   CEF_REQUIRE_UIT();
 }
@@ -116,15 +115,10 @@ void CefDevToolsManager::ShowDevTools(const CefWindowInfo& windowInfo,
     return;
   }
 
-  if (cef::IsChromeRuntimeEnabled()) {
-    NOTIMPLEMENTED();
-  } else {
-    auto alloy_browser = static_cast<AlloyBrowserHostImpl*>(inspected_browser_);
-    devtools_frontend_ = CefDevToolsFrontend::Show(
-        alloy_browser, windowInfo, client, settings, inspect_element_at,
-        base::BindOnce(&CefDevToolsManager::OnFrontEndDestroyed,
-                       weak_ptr_factory_.GetWeakPtr()));
-  }
+  devtools_frontend_ = CefDevToolsFrontend::Show(
+      inspected_browser_, windowInfo, client, settings, inspect_element_at,
+      base::BindOnce(&CefDevToolsManager::OnFrontEndDestroyed,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CefDevToolsManager::CloseDevTools() {
@@ -199,8 +193,8 @@ void CefDevToolsManager::OnFrontEndDestroyed() {
 
 bool CefDevToolsManager::EnsureController() {
   if (!devtools_controller_) {
-    devtools_controller_.reset(new CefDevToolsController(
-        inspected_browser_->contents_delegate()->web_contents()));
+    devtools_controller_.reset(
+        new CefDevToolsController(inspected_browser_->web_contents()));
   }
   return true;
 }

libcef/browser/devtools/devtools_manager.h

@@ -10,7 +10,7 @@
 
 #include "base/memory/weak_ptr.h"
 
-class CefBrowserHostBase;
+class AlloyBrowserHostImpl;
 class CefDevToolsController;
 class CefDevToolsFrontend;
 
@@ -23,7 +23,7 @@ class WebContents;
 class CefDevToolsManager {
  public:
   // |inspected_browser| will outlive this object.
-  explicit CefDevToolsManager(CefBrowserHostBase* inspected_browser);
+  explicit CefDevToolsManager(AlloyBrowserHostImpl* inspected_browser);
   ~CefDevToolsManager();
 
   // See CefBrowserHost methods of the same name for documentation.
@@ -52,7 +52,7 @@ class CefDevToolsManager {
 
   bool EnsureController();
 
-  CefBrowserHostBase* const inspected_browser_;
+  AlloyBrowserHostImpl* const inspected_browser_;
 
   // CefDevToolsFrontend will delete itself when the frontend WebContents is
   // destroyed.

libcef/browser/devtools/devtools_manager_delegate.cc

@@ -107,10 +107,8 @@ void CefDevToolsManagerDelegate::StartHttpHandler(
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kRemoteDebuggingPipe)) {
-    content::DevToolsAgentHost::StartRemoteDebuggingPipeHandler(
-        base::OnceClosure());
-  }
+  if (command_line.HasSwitch(switches::kRemoteDebuggingPipe))
+    content::DevToolsAgentHost::StartRemoteDebuggingPipeHandler();
 }
 
 // static

libcef/browser/extensions/alloy_extensions_util.cc

@@ -1,20 +0,0 @@
-// Copyright 2021 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.
-
-#include "libcef/browser/extensions/alloy_extensions_util.h"
-
-#include "libcef/browser/alloy/alloy_browser_host_impl.h"
-
-namespace extensions {
-namespace alloy {
-
-int GetTabIdForWebContents(content::WebContents* web_contents) {
-  auto browser = AlloyBrowserHostImpl::GetBrowserForContents(web_contents);
-  if (!browser)
-    return -1;
-  return browser->GetIdentifier();
-}
-
-}  // namespace alloy
-}  // namespace extensions

libcef/browser/extensions/alloy_extensions_util.h

@@ -1,21 +0,0 @@
-// Copyright 2021 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.
-
-#ifndef CEF_LIBCEF_BROWSER_EXTENSIONS_ALLOY_EXTENSIONS_UTIL_H_
-#define CEF_LIBCEF_BROWSER_EXTENSIONS_ALLOY_EXTENSIONS_UTIL_H_
-
-namespace content {
-class WebContents;
-}
-
-namespace extensions {
-namespace alloy {
-
-// Returns the tabId for |web_contents|, or -1 if not found.
-int GetTabIdForWebContents(content::WebContents* web_contents);
-
-}  // namespace alloy
-}  // namespace extensions
-
-#endif  // CEF_LIBCEF_BROWSER_EXTENSIONS_ALLOY_EXTENSIONS_UTIL_H_

libcef/browser/extensions/api/storage/sync_value_store_cache.cc

@@ -47,7 +47,7 @@ SyncValueStoreCache::~SyncValueStoreCache() {
 }
 
 void SyncValueStoreCache::RunWithValueStoreForExtension(
-    StorageCallback callback,
+    const StorageCallback& callback,
     scoped_refptr<const Extension> extension) {
   DCHECK(IsOnBackendSequence());
 
@@ -56,11 +56,11 @@ void SyncValueStoreCache::RunWithValueStoreForExtension(
   // A neat way to implement unlimited storage; if the extension has the
   // unlimited storage permission, force through all calls to Set().
   if (extension->permissions_data()->HasAPIPermission(
-          mojom::APIPermissionID::kUnlimitedStorage)) {
+          APIPermission::kUnlimitedStorage)) {
     WeakUnlimitedSettingsStorage unlimited_storage(storage);
-    std::move(callback).Run(&unlimited_storage);
+    callback.Run(&unlimited_storage);
   } else {
-    std::move(callback).Run(storage);
+    callback.Run(storage);
   }
 }
 

libcef/browser/extensions/api/storage/sync_value_store_cache.h

@@ -30,7 +30,7 @@ class SyncValueStoreCache : public ValueStoreCache {
 
   // ValueStoreCache implementation:
   void RunWithValueStoreForExtension(
-      StorageCallback callback,
+      const StorageCallback& callback,
       scoped_refptr<const Extension> extension) override;
   void DeleteStorageSoon(const std::string& extension_id) override;
 

libcef/browser/extensions/api/tabs/tabs_api.cc

@@ -6,15 +6,10 @@
 
 #include "libcef/browser/extensions/extension_web_contents_observer.h"
 
-#include "base/notreached.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
-#include "chrome/browser/extensions/extension_tab_util.h"
 #include "components/zoom/zoom_controller.h"
-#include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/site_instance.h"
 #include "extensions/browser/extension_api_frame_id_map.h"
 #include "extensions/browser/extension_zoom_request_client.h"
 #include "extensions/common/error_utils.h"
@@ -22,8 +17,6 @@
 #include "extensions/common/permissions/permissions_data.h"
 #include "third_party/blink/public/common/page/page_zoom.h"
 
-using zoom::ZoomController;
-
 namespace extensions {
 namespace cef {
 
@@ -104,148 +97,6 @@ ExtensionFunction::ResponseAction TabsCreateFunction::Run() {
           : NoArguments());
 }
 
-BaseAPIFunction::BaseAPIFunction() : cef_details_(this) {}
-
-content::WebContents* BaseAPIFunction::GetWebContents(int tab_id) {
-  // Find a browser that we can access, or set |error_| and return nullptr.
-  CefRefPtr<AlloyBrowserHostImpl> browser =
-      cef_details_.GetBrowserForTabIdFirstTime(tab_id, &error_);
-  if (!browser)
-    return nullptr;
-
-  return browser->web_contents();
-}
-
-ExtensionFunction::ResponseAction TabsUpdateFunction::Run() {
-  std::unique_ptr<tabs::Update::Params> params(
-      tabs::Update::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  tab_id_ = params->tab_id ? *params->tab_id : -1;
-  content::WebContents* web_contents = GetWebContents(tab_id_);
-  if (!web_contents)
-    return RespondNow(Error(std::move(error_)));
-
-  web_contents_ = web_contents;
-
-  // TODO(rafaelw): handle setting remaining tab properties:
-  // -title
-  // -favIconUrl
-
-  // Navigate the tab to a new location if the url is different.
-  if (params->update_properties.url.get()) {
-    std::string updated_url = *params->update_properties.url;
-    if (!UpdateURL(updated_url, tab_id_, &error_))
-      return RespondNow(Error(std::move(error_)));
-  }
-
-  bool active = false;
-  // TODO(rafaelw): Setting |active| from js doesn't make much sense.
-  // Move tab selection management up to window.
-  if (params->update_properties.selected.get())
-    active = *params->update_properties.selected;
-
-  // The 'active' property has replaced 'selected'.
-  if (params->update_properties.active.get())
-    active = *params->update_properties.active;
-
-  if (active) {
-    // TODO: Activate the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-    return RespondNow(Error(tabs_constants::kTabStripNotEditableError));
-  }
-
-  if (params->update_properties.highlighted.get() &&
-      *params->update_properties.highlighted) {
-    // TODO: Highlight the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-    return RespondNow(Error(tabs_constants::kTabStripNotEditableError));
-  }
-
-  if (params->update_properties.pinned.get() &&
-      *params->update_properties.pinned) {
-    // TODO: Pin the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-    return RespondNow(Error(tabs_constants::kTabStripNotEditableError));
-  }
-
-  if (params->update_properties.muted.get()) {
-    // TODO: Mute/unmute the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-    return RespondNow(Error(ErrorUtils::FormatErrorMessage(
-        tabs_constants::kCannotUpdateMuteCaptured,
-        base::NumberToString(tab_id_))));
-  }
-
-  if (params->update_properties.opener_tab_id.get()) {
-    int opener_id = *params->update_properties.opener_tab_id;
-    if (opener_id == tab_id_)
-      return RespondNow(Error("Cannot set a tab's opener to itself."));
-
-    // TODO: Set the opener for the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-    return RespondNow(Error(tabs_constants::kTabStripNotEditableError));
-  }
-
-  if (params->update_properties.auto_discardable.get()) {
-    // TODO: Set auto-discardable state for the tab at |tab_id_|.
-    NOTIMPLEMENTED();
-  }
-
-  return RespondNow(GetResult());
-}
-
-bool TabsUpdateFunction::UpdateURL(const std::string& url_string,
-                                   int tab_id,
-                                   std::string* error) {
-  GURL url;
-  if (!ExtensionTabUtil::PrepareURLForNavigation(url_string, extension(), &url,
-                                                 error)) {
-    return false;
-  }
-
-  const bool is_javascript_scheme = url.SchemeIs(url::kJavaScriptScheme);
-  // JavaScript URLs are forbidden in chrome.tabs.update().
-  if (is_javascript_scheme) {
-    *error = tabs_constants::kJavaScriptUrlsNotAllowedInTabsUpdate;
-    return false;
-  }
-
-  content::NavigationController::LoadURLParams load_params(url);
-
-  // Treat extension-initiated navigations as renderer-initiated so that the URL
-  // does not show in the omnibox until it commits.  This avoids URL spoofs
-  // since URLs can be opened on behalf of untrusted content.
-  load_params.is_renderer_initiated = true;
-  // All renderer-initiated navigations need to have an initiator origin.
-  load_params.initiator_origin = extension()->origin();
-  // |source_site_instance| needs to be set so that a renderer process
-  // compatible with |initiator_origin| is picked by Site Isolation.
-  load_params.source_site_instance = content::SiteInstance::CreateForURL(
-      web_contents_->GetBrowserContext(),
-      load_params.initiator_origin->GetURL());
-
-  // Marking the navigation as initiated via an API means that the focus
-  // will stay in the omnibox - see https://crbug.com/1085779.
-  load_params.transition_type = ui::PAGE_TRANSITION_FROM_API;
-
-  web_contents_->GetController().LoadURLWithParams(load_params);
-
-  DCHECK_EQ(url,
-            web_contents_->GetController().GetPendingEntry()->GetVirtualURL());
-
-  return true;
-}
-
-ExtensionFunction::ResponseValue TabsUpdateFunction::GetResult() {
-  if (!has_callback())
-    return NoArguments();
-
-  return ArgumentList(tabs::Get::Results::Create(*cef_details_.CreateTabObject(
-      AlloyBrowserHostImpl::GetBrowserForContents(web_contents_),
-      /*opener_browser_id=*/-1, /*active=*/true, tab_id_)));
-}
-
 ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
     : cef_details_(this), execute_tab_id_(-1) {}
 
@@ -277,8 +128,7 @@ ExecuteCodeFunction::InitResult ExecuteCodeInTabFunction::Init() {
 
   execute_tab_id_ = browser->GetIdentifier();
   details_ = std::move(details);
-  set_host_id(
-      mojom::HostID(mojom::HostID::HostType::kExtensions, extension()->id()));
+  set_host_id(HostID(HostID::EXTENSIONS, extension()->id()));
   return set_init_result(SUCCESS);
 }
 
@@ -332,7 +182,7 @@ bool ExecuteCodeInTabFunction::CanExecuteScriptOnPage(std::string* error) {
                                                       execute_tab_id_, error)) {
     if (is_about_url &&
         extension()->permissions_data()->active_permissions().HasAPIPermission(
-            mojom::APIPermissionID::kTab)) {
+            APIPermission::kTab)) {
       *error = ErrorUtils::FormatErrorMessage(
           manifest_errors::kCannotAccessAboutUrl,
           rfh->GetLastCommittedURL().spec(),
@@ -393,124 +243,165 @@ bool TabsRemoveCSSFunction::ShouldRemoveCSS() const {
   return true;
 }
 
-ExtensionFunction::ResponseAction TabsSetZoomFunction::Run() {
+ZoomAPIFunction::ZoomAPIFunction() : cef_details_(this) {}
+
+content::WebContents* ZoomAPIFunction::GetWebContents(int tab_id) {
+  // Find a browser that we can access, or set |error_| and return nullptr.
+  CefRefPtr<AlloyBrowserHostImpl> browser =
+      cef_details_.GetBrowserForTabIdFirstTime(tab_id, &error_);
+  if (!browser)
+    return nullptr;
+
+  return browser->web_contents();
+}
+
+void ZoomAPIFunction::SendResponse(bool success) {
+  ResponseValue response;
+  if (success) {
+    response = ArgumentList(std::move(results_));
+  } else {
+    response = results_ ? ErrorWithArguments(std::move(results_), error_)
+                        : Error(error_);
+  }
+  Respond(std::move(response));
+}
+
+ExtensionFunction::ResponseAction ZoomAPIFunction::Run() {
+  if (RunAsync())
+    return RespondLater();
+  // TODO(devlin): Track these down and eliminate them if possible. We
+  // shouldn't return results and an error.
+  if (results_)
+    return RespondNow(ErrorWithArguments(std::move(results_), error_));
+  return RespondNow(Error(error_));
+}
+
+bool TabsSetZoomFunction::RunAsync() {
   std::unique_ptr<tabs::SetZoom::Params> params(
       tabs::SetZoom::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params);
+  EXTENSION_FUNCTION_PRERUN_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
-    return RespondNow(Error(std::move(error_)));
+    return false;
 
   GURL url(web_contents->GetVisibleURL());
   if (extension()->permissions_data()->IsRestrictedUrl(url, &error_))
-    return RespondNow(Error(std::move(error_)));
+    return false;
 
-  ZoomController* zoom_controller =
-      ZoomController::FromWebContents(web_contents);
+  zoom::ZoomController* zoom_controller =
+      zoom::ZoomController::FromWebContents(web_contents);
   double zoom_level =
       params->zoom_factor > 0
           ? blink::PageZoomFactorToZoomLevel(params->zoom_factor)
           : zoom_controller->GetDefaultZoomLevel();
 
-  auto client = base::MakeRefCounted<ExtensionZoomRequestClient>(extension());
+  scoped_refptr<extensions::ExtensionZoomRequestClient> client(
+      new extensions::ExtensionZoomRequestClient(extension()));
   if (!zoom_controller->SetZoomLevelByClient(zoom_level, client)) {
     // Tried to zoom a tab in disabled mode.
-    return RespondNow(Error(tabs_constants::kCannotZoomDisabledTabError));
+    error_ = keys::kCannotZoomDisabledTabError;
+    return false;
   }
 
-  return RespondNow(NoArguments());
+  SendResponse(true);
+  return true;
 }
 
-ExtensionFunction::ResponseAction TabsGetZoomFunction::Run() {
+bool TabsGetZoomFunction::RunAsync() {
   std::unique_ptr<tabs::GetZoom::Params> params(
       tabs::GetZoom::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params);
+  EXTENSION_FUNCTION_PRERUN_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
-    return RespondNow(Error(std::move(error_)));
+    return false;
 
   double zoom_level =
       zoom::ZoomController::FromWebContents(web_contents)->GetZoomLevel();
   double zoom_factor = blink::PageZoomLevelToZoomFactor(zoom_level);
-
-  return RespondNow(ArgumentList(tabs::GetZoom::Results::Create(zoom_factor)));
+  results_ = tabs::GetZoom::Results::Create(zoom_factor);
+  SendResponse(true);
+  return true;
 }
 
-ExtensionFunction::ResponseAction TabsSetZoomSettingsFunction::Run() {
+bool TabsSetZoomSettingsFunction::RunAsync() {
   using api::tabs::ZoomSettings;
 
   std::unique_ptr<tabs::SetZoomSettings::Params> params(
       tabs::SetZoomSettings::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params);
+  EXTENSION_FUNCTION_PRERUN_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
-    return RespondNow(Error(std::move(error_)));
+    return false;
 
   GURL url(web_contents->GetVisibleURL());
-  std::string error;
   if (extension()->permissions_data()->IsRestrictedUrl(url, &error_))
-    return RespondNow(Error(std::move(error_)));
+    return false;
 
   // "per-origin" scope is only available in "automatic" mode.
   if (params->zoom_settings.scope == tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN &&
       params->zoom_settings.mode != tabs::ZOOM_SETTINGS_MODE_AUTOMATIC &&
       params->zoom_settings.mode != tabs::ZOOM_SETTINGS_MODE_NONE) {
-    return RespondNow(Error(tabs_constants::kPerOriginOnlyInAutomaticError));
+    error_ = keys::kPerOriginOnlyInAutomaticError;
+    return false;
   }
 
   // Determine the correct internal zoom mode to set |web_contents| to from the
   // user-specified |zoom_settings|.
-  ZoomController::ZoomMode zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
+  zoom::ZoomController::ZoomMode zoom_mode =
+      zoom::ZoomController::ZOOM_MODE_DEFAULT;
   switch (params->zoom_settings.mode) {
     case tabs::ZOOM_SETTINGS_MODE_NONE:
     case tabs::ZOOM_SETTINGS_MODE_AUTOMATIC:
       switch (params->zoom_settings.scope) {
         case tabs::ZOOM_SETTINGS_SCOPE_NONE:
         case tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN:
-          zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
+          zoom_mode = zoom::ZoomController::ZOOM_MODE_DEFAULT;
           break;
         case tabs::ZOOM_SETTINGS_SCOPE_PER_TAB:
-          zoom_mode = ZoomController::ZOOM_MODE_ISOLATED;
+          zoom_mode = zoom::ZoomController::ZOOM_MODE_ISOLATED;
       }
       break;
     case tabs::ZOOM_SETTINGS_MODE_MANUAL:
-      zoom_mode = ZoomController::ZOOM_MODE_MANUAL;
+      zoom_mode = zoom::ZoomController::ZOOM_MODE_MANUAL;
       break;
     case tabs::ZOOM_SETTINGS_MODE_DISABLED:
-      zoom_mode = ZoomController::ZOOM_MODE_DISABLED;
+      zoom_mode = zoom::ZoomController::ZOOM_MODE_DISABLED;
   }
 
-  ZoomController::FromWebContents(web_contents)->SetZoomMode(zoom_mode);
+  zoom::ZoomController::FromWebContents(web_contents)->SetZoomMode(zoom_mode);
 
-  return RespondNow(NoArguments());
+  SendResponse(true);
+  return true;
 }
 
-ExtensionFunction::ResponseAction TabsGetZoomSettingsFunction::Run() {
+bool TabsGetZoomSettingsFunction::RunAsync() {
   std::unique_ptr<tabs::GetZoomSettings::Params> params(
       tabs::GetZoomSettings::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params);
+  EXTENSION_FUNCTION_PRERUN_VALIDATE(params);
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
-    return RespondNow(Error(std::move(error_)));
-  ZoomController* zoom_controller =
-      ZoomController::FromWebContents(web_contents);
+    return false;
+  zoom::ZoomController* zoom_controller =
+      zoom::ZoomController::FromWebContents(web_contents);
 
-  ZoomController::ZoomMode zoom_mode = zoom_controller->zoom_mode();
+  zoom::ZoomController::ZoomMode zoom_mode = zoom_controller->zoom_mode();
   api::tabs::ZoomSettings zoom_settings;
   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
-  zoom_settings.default_zoom_factor = std::make_unique<double>(
-      blink::PageZoomLevelToZoomFactor(zoom_controller->GetDefaultZoomLevel()));
+  zoom_settings.default_zoom_factor.reset(
+      new double(blink::PageZoomLevelToZoomFactor(
+          zoom_controller->GetDefaultZoomLevel())));
 
-  return RespondNow(
-      ArgumentList(api::tabs::GetZoomSettings::Results::Create(zoom_settings)));
+  results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
+  SendResponse(true);
+  return true;
 }
 
 }  // namespace cef

libcef/browser/extensions/api/tabs/tabs_api.h

@@ -42,37 +42,6 @@ class TabsCreateFunction : public ExtensionFunction {
   const CefExtensionFunctionDetails cef_details_;
 };
 
-class BaseAPIFunction : public ExtensionFunction {
- public:
-  BaseAPIFunction();
-
- protected:
-  ~BaseAPIFunction() override {}
-
-  // Gets the WebContents for |tab_id| if it is specified. Otherwise get the
-  // WebContents for the active tab in the current window. Calling this function
-  // may set |error_|.
-  content::WebContents* GetWebContents(int tab_id);
-
-  std::string error_;
-  const CefExtensionFunctionDetails cef_details_;
-};
-
-class TabsUpdateFunction : public BaseAPIFunction {
- private:
-  ~TabsUpdateFunction() override {}
-
-  ResponseAction Run() override;
-
-  bool UpdateURL(const std::string& url, int tab_id, std::string* error);
-  ResponseValue GetResult();
-
-  DECLARE_EXTENSION_FUNCTION("tabs.update", TABS_UPDATE)
-
-  int tab_id_ = -1;
-  content::WebContents* web_contents_ = nullptr;
-};
-
 // Implement API calls tabs.executeScript, tabs.insertCSS, and tabs.removeCSS.
 class ExecuteCodeInTabFunction : public ExecuteCodeFunction {
  public:
@@ -139,44 +108,58 @@ class ZoomAPIFunction : public ExtensionFunction {
   // may set |error_|.
   content::WebContents* GetWebContents(int tab_id);
 
+  virtual bool RunAsync() = 0;
+
+  // Responds with success/failure. |results_| or |error_| should be set
+  // accordingly.
+  void SendResponse(bool success);
+
+  // Exposed versions of ExtensionFunction::results_ and
+  // ExtensionFunction::error_ that are curried into the response.
+  // These need to keep the same name to avoid breaking existing
+  // implementations, but this should be temporary with crbug.com/648275
+  // and crbug.com/634140.
+  std::unique_ptr<base::ListValue> results_;
   std::string error_;
 
  private:
+  ResponseAction Run() final;
+
   const CefExtensionFunctionDetails cef_details_;
 };
 
-class TabsSetZoomFunction : public BaseAPIFunction {
+class TabsSetZoomFunction : public ZoomAPIFunction {
  private:
   ~TabsSetZoomFunction() override {}
 
-  ResponseAction Run() override;
+  bool RunAsync() override;
 
   DECLARE_EXTENSION_FUNCTION("tabs.setZoom", TABS_SETZOOM)
 };
 
-class TabsGetZoomFunction : public BaseAPIFunction {
+class TabsGetZoomFunction : public ZoomAPIFunction {
  private:
   ~TabsGetZoomFunction() override {}
 
-  ResponseAction Run() override;
+  bool RunAsync() override;
 
   DECLARE_EXTENSION_FUNCTION("tabs.getZoom", TABS_GETZOOM)
 };
 
-class TabsSetZoomSettingsFunction : public BaseAPIFunction {
+class TabsSetZoomSettingsFunction : public ZoomAPIFunction {
  private:
   ~TabsSetZoomSettingsFunction() override {}
 
-  ResponseAction Run() override;
+  bool RunAsync() override;
 
   DECLARE_EXTENSION_FUNCTION("tabs.setZoomSettings", TABS_SETZOOMSETTINGS)
 };
 
-class TabsGetZoomSettingsFunction : public BaseAPIFunction {
+class TabsGetZoomSettingsFunction : public ZoomAPIFunction {
  private:
   ~TabsGetZoomSettingsFunction() override {}
 
-  ResponseAction Run() override;
+  bool RunAsync() override;
 
   DECLARE_EXTENSION_FUNCTION("tabs.getZoomSettings", TABS_GETZOOMSETTINGS)
 };