Update to Chromium revision 68623971 (#403382)

libcef/browser/chrome_browser_process_stub.cc

@@ -208,6 +208,12 @@ safe_browsing::ClientSideDetectionService*
   return NULL;
 }
 
+subresource_filter::RulesetService*
+    ChromeBrowserProcessStub::subresource_filter_ruleset_service() {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
 void ChromeBrowserProcessStub::StartAutoupdateTimer() {
 }

libcef/browser/chrome_browser_process_stub.h

@@ -72,6 +72,8 @@ class ChromeBrowserProcessStub : public BrowserProcess {
   safe_browsing::SafeBrowsingService* safe_browsing_service() override;
   safe_browsing::ClientSideDetectionService*
       safe_browsing_detection_service() override;
+  subresource_filter::RulesetService*
+      subresource_filter_ruleset_service() override;
 
 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
   void StartAutoupdateTimer() override;

libcef/browser/content_browser_client.cc

@@ -51,6 +51,7 @@
 #include "content/public/browser/browser_url_handler.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/client_certificate_delegate.h"
+#include "content/public/browser/geolocation_delegate.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/quota_permission_context.h"
@@ -116,6 +117,23 @@ class CefAccessTokenStore : public content::AccessTokenStore {
   DISALLOW_COPY_AND_ASSIGN(CefAccessTokenStore);
 };
 
+// A provider of services for geolocation.
+class CefGeolocationDelegate : public content::GeolocationDelegate {
+ public:
+  explicit CefGeolocationDelegate(net::URLRequestContextGetter* system_context)
+      : system_context_(system_context) {}
+
+  content::AccessTokenStore* CreateAccessTokenStore() override {
+    return new CefAccessTokenStore(system_context_);
+  }
+
+ private:
+  net::URLRequestContextGetter* system_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefGeolocationDelegate);
+};
+
+
 class CefQuotaCallbackImpl : public CefRequestCallback {
  public:
   explicit CefQuotaCallbackImpl(
@@ -674,8 +692,9 @@ void CefContentBrowserClient::SelectClientCertificate(
   }
 }
 
-content::AccessTokenStore* CefContentBrowserClient::CreateAccessTokenStore() {
-  return new CefAccessTokenStore(
+content::GeolocationDelegate*
+    CefContentBrowserClient::CreateGeolocationDelegate() {
+  return new CefGeolocationDelegate(
       browser_main_parts_->browser_context()->request_context().get());
 }
 

libcef/browser/content_browser_client.h

@@ -66,7 +66,7 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       std::unique_ptr<content::ClientCertificateDelegate> delegate) override;
-  content::AccessTokenStore* CreateAccessTokenStore() override;
+  content::GeolocationDelegate* CreateGeolocationDelegate() override;
   bool CanCreateWindow(const GURL& opener_url,
                        const GURL& opener_top_level_frame_url,
                        const GURL& source_origin,

libcef/browser/extensions/extensions_browser_client.cc

@@ -170,12 +170,6 @@ bool CefExtensionsBrowserClient::IsLoggedInAsPublicAccount()  {
   return false;
 }
 
-ApiActivityMonitor* CefExtensionsBrowserClient::GetApiActivityMonitor(
-    BrowserContext* context) {
-  // CEF doesn't monitor API function calls or events.
-  return NULL;
-}
-
 ExtensionSystemProvider*
 CefExtensionsBrowserClient::GetExtensionSystemFactory() {
   return CefExtensionSystemFactory::GetInstance();

libcef/browser/extensions/extensions_browser_client.h

@@ -64,8 +64,6 @@ class CefExtensionsBrowserClient : public ExtensionsBrowserClient {
   void PermitExternalProtocolHandler() override;
   bool IsRunningInForcedAppMode() override;
   bool IsLoggedInAsPublicAccount() override;
-  ApiActivityMonitor* GetApiActivityMonitor(
-      content::BrowserContext* context) override;
   ExtensionSystemProvider* GetExtensionSystemFactory() override;
   void RegisterExtensionFunctions(
       ExtensionFunctionRegistry* registry) const override;

libcef/browser/native/browser_platform_delegate_native_linux.cc

@@ -21,6 +21,11 @@
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/renderer_preferences.h"
+#include "ui/events/keycodes/dom/dom_key.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/keycodes/keyboard_code_conversion_x.h"
+#include "ui/events/keycodes/keyboard_code_conversion_xkb.h"
+#include "ui/events/keycodes/keysym_to_unicode.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/widget/widget.h"
@@ -268,6 +273,17 @@ void CefBrowserPlatformDelegateNativeLinux::TranslateKeyEvent(
     NOTREACHED();
   }
 
+  // Populate DOM values that will be passed to JavaScript handlers via
+  // KeyboardEvent.
+  result.domCode =
+      static_cast<int>(ui::KeycodeConverter::NativeKeycodeToDomCode(
+            key_event.native_key_code));
+  int keysym = ui::XKeysymForWindowsKeyCode(
+      static_cast<ui::KeyboardCode>(key_event.windows_key_code),
+      !!(key_event.modifiers & EVENTFLAG_SHIFT_DOWN));
+  base::char16 ch = ui::GetUnicodeCharacterFromXKeySym(keysym);
+  result.domKey = static_cast<int>(ui::XKeySymToDomKey(keysym, ch));
+
   result.text[0] = key_event.character;
   result.unmodifiedText[0] = key_event.unmodified_character;
 

libcef/browser/native/browser_platform_delegate_native_win.cc

@@ -25,6 +25,10 @@
 #include "ui/base/win/shell.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/events/keycodes/dom/dom_key.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/keycodes/keyboard_code_conversion_win.h"
+#include "ui/events/keycodes/platform_key_map_win.h"
 #include "ui/gfx/win/hwnd_util.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
 #include "ui/views/widget/widget.h"
@@ -382,6 +386,21 @@ void CefBrowserPlatformDelegateNativeWin::TranslateKeyEvent(
     NOTREACHED();
   }
 
+  // Populate DOM values that will be passed to JavaScript handlers via
+  // KeyboardEvent.
+  result.domCode =
+      static_cast<int>(ui::KeycodeConverter::NativeKeycodeToDomCode(
+            key_event.native_key_code));
+  if (result.type == blink::WebInputEvent::Char) {
+    result.domKey = ui::DomKey::FromCharacter(key_event.windows_key_code);
+  } else {
+    // TODO(cef): CefKeyEvent does not currently pass extended key status (see
+    // WM_KEYDOWN docs) which would be necessary to pass EF_IS_EXTENDED_KEY as
+    // the |flags| parameter to DomKeyFromKeyboardCode().
+    result.domKey = ui::PlatformKeyMap::DomKeyFromKeyboardCode(
+        ui::KeyboardCodeForWindowsKeyCode(key_event.windows_key_code), 0);
+  }
+
   if (result.type == blink::WebInputEvent::Char ||
       result.type == blink::WebInputEvent::RawKeyDown) {
     result.text[0] = result.windowsKeyCode;

libcef/browser/net/url_request_context_getter_impl.cc

@@ -34,6 +34,8 @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "net/cert/cert_verifier.h"
+#include "net/cert/ct_policy_enforcer.h"
+#include "net/cert/multi_log_ct_verifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 #include "net/dns/host_resolver.h"
@@ -207,6 +209,10 @@ net::URLRequestContext* CefURLRequestContextGetterImpl::GetURLRequestContext() {
     storage_->set_cert_verifier(net::CertVerifier::CreateDefault());
     storage_->set_transport_security_state(
         base::WrapUnique(new net::TransportSecurityState));
+    storage_->set_cert_transparency_verifier(
+        base::WrapUnique(new net::MultiLogCTVerifier));
+    storage_->set_ct_policy_enforcer(
+        base::WrapUnique(new net::CTPolicyEnforcer));
 
     std::unique_ptr<net::ProxyService> system_proxy_service =
         ProxyServiceFactory::CreateProxyService(
@@ -257,6 +263,10 @@ net::URLRequestContext* CefURLRequestContextGetterImpl::GetURLRequestContext() {
         url_request_context_->cert_verifier();
     network_session_params.transport_security_state =
         url_request_context_->transport_security_state();
+    network_session_params.cert_transparency_verifier =
+        url_request_context_->cert_transparency_verifier();
+    network_session_params.ct_policy_enforcer =
+        url_request_context_->ct_policy_enforcer();
     network_session_params.channel_id_service =
         url_request_context_->channel_id_service();
     network_session_params.proxy_service =

libcef/browser/osr/render_widget_host_view_osr.cc

@@ -104,7 +104,7 @@ class CefResizeLock : public content::ResizeLock {
  protected:
   void LockCompositor() override {
     ResizeLock::LockCompositor();
-    compositor_lock_ = host_->compositor()->GetCompositorLock();
+    compositor_lock_ = host_->GetCompositor()->GetCompositorLock();
   }
 
   void CancelLock() {
@@ -451,8 +451,10 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
     : transparent_(transparent),
       scale_factor_(kDefaultScaleFactor),
       frame_rate_threshold_ms_(0),
-      delegated_frame_host_(new content::DelegatedFrameHost(this)),
+#if !defined(OS_MACOSX)
       compositor_widget_(gfx::kNullAcceleratedWidget),
+      delegated_frame_host_(new content::DelegatedFrameHost(this)),
+#endif
       software_output_device_(NULL),
       hold_resize_(false),
       pending_resize_(false),
@@ -477,38 +479,48 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
         content::RenderViewHost::From(render_widget_host_));
   }
 
+#if !defined(OS_MACOSX)
   root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
+#endif
 
   PlatformCreateCompositorWidget();
+
 #if !defined(OS_MACOSX)
   // On OS X the ui::Compositor is created/owned by the platform view.
   compositor_.reset(
       new ui::Compositor(content::GetContextFactory(),
                          base::ThreadTaskRunnerHandle::Get()));
   compositor_->SetAcceleratedWidget(compositor_widget_);
-#endif
   compositor_->SetDelegate(this);
   compositor_->SetRootLayer(root_layer_.get());
+#endif
 
   if (browser_impl_.get())
     ResizeRootLayer();
 }
 
 CefRenderWidgetHostViewOSR::~CefRenderWidgetHostViewOSR() {
+#if defined(OS_MACOSX)
+  if (is_showing_)
+    browser_compositor_->SetRenderWidgetHostIsHidden(true);
+#else
   // Marking the DelegatedFrameHost as removed from the window hierarchy is
   // necessary to remove all connections to its old ui::Compositor.
   if (is_showing_)
     delegated_frame_host_->WasHidden();
   delegated_frame_host_->ResetCompositor();
+#endif
 
   PlatformDestroyCompositorWidget();
 
   if (copy_frame_generator_.get())
     copy_frame_generator_.reset(NULL);
 
+#if !defined(OS_MACOSX)
   delegated_frame_host_.reset(NULL);
   compositor_.reset(NULL);
   root_layer_.reset(NULL);
+#endif
 
   DCHECK(parent_host_view_ == NULL);
   DCHECK(popup_host_view_ == NULL);
@@ -572,7 +584,7 @@ bool CefRenderWidgetHostViewOSR::HasFocus() const {
 }
 
 bool CefRenderWidgetHostViewOSR::IsSurfaceAvailableForCopy() const {
-  return delegated_frame_host_->CanCopyToBitmap();
+  return GetDelegatedFrameHost()->CanCopyToBitmap();
 }
 
 void CefRenderWidgetHostViewOSR::Show() {
@@ -580,10 +592,16 @@ void CefRenderWidgetHostViewOSR::Show() {
     return;
 
   is_showing_ = true;
-  if (render_widget_host_)
-    render_widget_host_->WasShown(ui::LatencyInfo());
+
+#if defined(OS_MACOSX)
+  browser_compositor_->SetRenderWidgetHostIsHidden(false);
+#else
   delegated_frame_host_->SetCompositor(compositor_.get());
   delegated_frame_host_->WasShown(ui::LatencyInfo());
+#endif
+
+  if (render_widget_host_)
+    render_widget_host_->WasShown(ui::LatencyInfo());
 }
 
 void CefRenderWidgetHostViewOSR::Hide() {
@@ -595,8 +613,14 @@ void CefRenderWidgetHostViewOSR::Hide() {
 
   if (render_widget_host_)
     render_widget_host_->WasHidden();
-  delegated_frame_host_->WasHidden();
-  delegated_frame_host_->ResetCompositor();
+
+#if defined(OS_MACOSX)
+  browser_compositor_->SetRenderWidgetHostIsHidden(true);
+#else
+  GetDelegatedFrameHost()->WasHidden();
+  GetDelegatedFrameHost()->ResetCompositor();
+#endif
+
   is_showing_ = false;
 }
 
@@ -639,11 +663,11 @@ void CefRenderWidgetHostViewOSR::UnlockMouse() {
 
 void CefRenderWidgetHostViewOSR::OnSwapCompositorFrame(
     uint32_t output_surface_id,
-    std::unique_ptr<cc::CompositorFrame> frame) {
+    cc::CompositorFrame frame) {
   TRACE_EVENT0("libcef", "CefRenderWidgetHostViewOSR::OnSwapCompositorFrame");
 
-  if (frame->metadata.root_scroll_offset != last_scroll_offset_) {
-    last_scroll_offset_ = frame->metadata.root_scroll_offset;
+  if (frame.metadata.root_scroll_offset != last_scroll_offset_) {
+    last_scroll_offset_ = frame.metadata.root_scroll_offset;
 
     if (!is_scroll_offset_changed_pending_) {
       // Send the notification asnychronously.
@@ -653,7 +677,7 @@ void CefRenderWidgetHostViewOSR::OnSwapCompositorFrame(
     }
   }
 
-  if (frame->delegated_frame_data) {
+  if (frame.delegated_frame_data) {
     if (software_output_device_) {
       if (!begin_frame_timer_.get()) {
         // If BeginFrame scheduling is enabled SoftwareOutputDevice activity
@@ -664,8 +688,13 @@ void CefRenderWidgetHostViewOSR::OnSwapCompositorFrame(
 
       // The compositor will draw directly to the SoftwareOutputDevice which
       // then calls OnPaint.
+#if defined(OS_MACOSX)
+      browser_compositor_->SwapCompositorFrame(output_surface_id,
+                                               std::move(frame));
+#else
       delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
                                                 std::move(frame));
+#endif
     } else {
       if (!copy_frame_generator_.get()) {
         copy_frame_generator_.reset(
@@ -675,14 +704,19 @@ void CefRenderWidgetHostViewOSR::OnSwapCompositorFrame(
       // Determine the damage rectangle for the current frame. This is the same
       // calculation that SwapDelegatedFrame uses.
       cc::RenderPass* root_pass =
-          frame->delegated_frame_data->render_pass_list.back().get();
+          frame.delegated_frame_data->render_pass_list.back().get();
       gfx::Size frame_size = root_pass->output_rect.size();
       gfx::Rect damage_rect =
           gfx::ToEnclosingRect(gfx::RectF(root_pass->damage_rect));
       damage_rect.Intersect(gfx::Rect(frame_size));
 
+#if defined(OS_MACOSX)
+      browser_compositor_->SwapCompositorFrame(output_surface_id,
+                                               std::move(frame));
+#else
       delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
                                                 std::move(frame));
+#endif
 
       // Request a copy of the last compositor frame which will eventually call
       // OnPaint asynchronously.
@@ -694,7 +728,7 @@ void CefRenderWidgetHostViewOSR::OnSwapCompositorFrame(
 }
 
 void CefRenderWidgetHostViewOSR::ClearCompositorFrame() {
-  delegated_frame_host_->ClearDelegatedFrame();
+  GetDelegatedFrameHost()->ClearDelegatedFrame();
 }
 
 void CefRenderWidgetHostViewOSR::InitAsPopup(
@@ -835,7 +869,7 @@ void CefRenderWidgetHostViewOSR::SetTooltipText(
 }
 
 gfx::Size CefRenderWidgetHostViewOSR::GetRequestedRendererSize() const {
-  return delegated_frame_host_->GetRequestedRendererSize();
+  return GetDelegatedFrameHost()->GetRequestedRendererSize();
 }
 
 gfx::Size CefRenderWidgetHostViewOSR::GetPhysicalBackingSize() const {
@@ -853,7 +887,7 @@ void CefRenderWidgetHostViewOSR::CopyFromCompositingSurface(
     const gfx::Size& dst_size,
     const content::ReadbackRequestCallback& callback,
     const SkColorType color_type) {
-  delegated_frame_host_->CopyFromCompositingSurface(
+  GetDelegatedFrameHost()->CopyFromCompositingSurface(
       src_subrect, dst_size, callback, color_type);
 }
 
@@ -861,21 +895,21 @@ void CefRenderWidgetHostViewOSR::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
-  delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
+  GetDelegatedFrameHost()->CopyFromCompositingSurfaceToVideoFrame(
       src_subrect, target, callback);
 }
 
 bool CefRenderWidgetHostViewOSR::CanCopyToVideoFrame() const {
-  return delegated_frame_host_->CanCopyToVideoFrame();
+  return GetDelegatedFrameHost()->CanCopyToVideoFrame();
 }
 
 void CefRenderWidgetHostViewOSR::BeginFrameSubscription(
     std::unique_ptr<content::RenderWidgetHostViewFrameSubscriber> subscriber) {
-  delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
+  GetDelegatedFrameHost()->BeginFrameSubscription(std::move(subscriber));
 }
 
 void CefRenderWidgetHostViewOSR::EndFrameSubscription() {
-  delegated_frame_host_->EndFrameSubscription();
+  GetDelegatedFrameHost()->EndFrameSubscription();
 }
 
 bool CefRenderWidgetHostViewOSR::HasAcceleratedSurface(
@@ -921,13 +955,6 @@ void CefRenderWidgetHostViewOSR::GetScreenInfo(blink::WebScreenInfo* results) {
   *results = webScreenInfoFrom(screen_info);
 }
 
-bool CefRenderWidgetHostViewOSR::GetScreenColorProfile(
-    std::vector<char>* color_profile) {
-  DCHECK(color_profile->empty());
-  // TODO(cef): Maybe expose this method to the client?
-  return false;
-}
-
 gfx::Rect CefRenderWidgetHostViewOSR::GetBoundsInRootWindow() {
   if (!browser_impl_.get())
     return gfx::Rect();
@@ -998,7 +1025,7 @@ void CefRenderWidgetHostViewOSR::OnSetNeedsBeginFrames(bool enabled) {
 std::unique_ptr<cc::SoftwareOutputDevice>
 CefRenderWidgetHostViewOSR::CreateSoftwareOutputDevice(
     ui::Compositor* compositor) {
-  DCHECK_EQ(compositor_.get(), compositor);
+  DCHECK_EQ(GetCompositor(), compositor);
   DCHECK(!copy_frame_generator_);
   DCHECK(!software_output_device_);
   software_output_device_ = new CefSoftwareOutputDeviceOSR(
@@ -1014,7 +1041,7 @@ int CefRenderWidgetHostViewOSR::DelegatedFrameHostGetGpuMemoryBufferClientId()
 }
 
 ui::Layer* CefRenderWidgetHostViewOSR::DelegatedFrameHostGetLayer() const {
-  return root_layer_.get();
+  return GetRootLayer();
 }
 
 bool CefRenderWidgetHostViewOSR::DelegatedFrameHostIsVisible() const {
@@ -1035,7 +1062,7 @@ SkColor CefRenderWidgetHostViewOSR::DelegatedFrameHostGetGutterColor(
 
 gfx::Size
 CefRenderWidgetHostViewOSR::DelegatedFrameHostDesiredSizeInDIP() const {
-  return root_layer_->bounds().size();
+  return GetRootLayer()->bounds().size();
 }
 
 bool CefRenderWidgetHostViewOSR::DelegatedFrameCanCreateResizeLock() const {
@@ -1045,7 +1072,7 @@ bool CefRenderWidgetHostViewOSR::DelegatedFrameCanCreateResizeLock() const {
 std::unique_ptr<content::ResizeLock>
 CefRenderWidgetHostViewOSR::DelegatedFrameHostCreateResizeLock(
     bool defer_compositor_lock) {
-  const gfx::Size& desired_size = root_layer_->bounds().size();
+  const gfx::Size& desired_size = GetRootLayer()->bounds().size();
   return std::unique_ptr<content::ResizeLock>(new CefResizeLock(
       this,
       desired_size,
@@ -1094,7 +1121,11 @@ void CefRenderWidgetHostViewOSR::SetBeginFrameSource(
 bool CefRenderWidgetHostViewOSR::InstallTransparency() {
   if (transparent_) {
     SetBackgroundColor(SkColor());
+#if defined(OS_MACOSX)
+    browser_compositor_->SetHasTransparentBackground(true);
+#else
     compositor_->SetHostHasTransparentBackground(true);
+#endif
     return true;
   }
   return false;
@@ -1110,7 +1141,7 @@ void CefRenderWidgetHostViewOSR::WasResized() {
   ResizeRootLayer();
   if (render_widget_host_)
     render_widget_host_->WasResized();
-  delegated_frame_host_->WasResized();
+  GetDelegatedFrameHost()->WasResized();
 }
 
 void CefRenderWidgetHostViewOSR::OnScreenInfoChanged() {
@@ -1306,6 +1337,21 @@ void CefRenderWidgetHostViewOSR::RemoveGuestHostView(
   guest_host_views_.erase(guest_host);
 }
 
+#if !defined(OS_MACOSX)
+ui::Compositor* CefRenderWidgetHostViewOSR::GetCompositor() const {
+  return compositor_.get();
+}
+
+content::DelegatedFrameHost* CefRenderWidgetHostViewOSR::GetDelegatedFrameHost()
+    const {
+  return delegated_frame_host_.get();
+}
+
+ui::Layer* CefRenderWidgetHostViewOSR::GetRootLayer() const {
+  return root_layer_.get();
+}
+#endif  // !defined(OS_MACOSX)
+
 void CefRenderWidgetHostViewOSR::SetFrameRate() {
   CefRefPtr<CefBrowserHostImpl> browser;
   if (parent_host_view_) {
@@ -1325,7 +1371,7 @@ void CefRenderWidgetHostViewOSR::SetFrameRate() {
   frame_rate_threshold_ms_ = 1000 / frame_rate;
 
   // Configure the VSync interval for the browser process.
-  compositor_->vsync_manager()->SetAuthoritativeVSyncInterval(
+  GetCompositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
       base::TimeDelta::FromMilliseconds(frame_rate_threshold_ms_));
 
   if (copy_frame_generator_.get()) {
@@ -1375,14 +1421,14 @@ void CefRenderWidgetHostViewOSR::ResizeRootLayer() {
   else
     size = popup_position_.size();
 
-  if (!scaleFactorDidChange && size == root_layer_->bounds().size())
+  if (!scaleFactorDidChange && size == GetRootLayer()->bounds().size())
     return;
 
   const gfx::Size& size_in_pixels =
       gfx::ConvertSizeToPixel(scale_factor_, size);
 
-  root_layer_->SetBounds(gfx::Rect(size));
-  compositor_->SetScaleAndSize(scale_factor_, size_in_pixels);
+  GetRootLayer()->SetBounds(gfx::Rect(size));
+  GetCompositor()->SetScaleAndSize(scale_factor_, size_in_pixels);
 }
 
 bool CefRenderWidgetHostViewOSR::IsFramePending() {

libcef/browser/osr/render_widget_host_view_osr.h

@@ -120,9 +120,8 @@ class CefRenderWidgetHostViewOSR
 #endif  // defined(OS_MACOSX)
 
   // RenderWidgetHostViewBase implementation.
-  void OnSwapCompositorFrame(
-      uint32_t output_surface_id,
-      std::unique_ptr<cc::CompositorFrame> frame) override;
+  void OnSwapCompositorFrame(uint32_t output_surface_id,
+                             cc::CompositorFrame frame) override;
   void ClearCompositorFrame() override;
   void InitAsPopup(content::RenderWidgetHostView* parent_host_view,
                    const gfx::Rect& pos) override;
@@ -163,7 +162,6 @@ class CefRenderWidgetHostViewOSR
   void EndFrameSubscription() override;
   bool HasAcceleratedSurface(const gfx::Size& desired_size) override;
   void GetScreenInfo(blink::WebScreenInfo* results) override;
-  bool GetScreenColorProfile(std::vector<char>* color_profile) override;
   gfx::Rect GetBoundsInRootWindow() override;
   content::BrowserAccessibilityManager*
       CreateBrowserAccessibilityManager(
@@ -266,11 +264,14 @@ class CefRenderWidgetHostViewOSR
     child_host_view_ = popup_view;
   }
 
-  ui::Compositor* compositor() const { return compositor_.get(); }
+  ui::Compositor* GetCompositor() const;
   content::RenderWidgetHostImpl* render_widget_host() const
       { return render_widget_host_; }
 
  private:
+  content::DelegatedFrameHost* GetDelegatedFrameHost() const;
+  ui::Layer* GetRootLayer() const;
+
   void SetFrameRate();
   void SetDeviceScaleFactor();
   void ResizeRootLayer();
@@ -323,10 +324,12 @@ class CefRenderWidgetHostViewOSR
   float scale_factor_;
   int frame_rate_threshold_ms_;
 
-  std::unique_ptr<content::DelegatedFrameHost> delegated_frame_host_;
+#if !defined(OS_MACOSX)
   std::unique_ptr<ui::Compositor> compositor_;
   gfx::AcceleratedWidget compositor_widget_;
+  std::unique_ptr<content::DelegatedFrameHost> delegated_frame_host_;
   std::unique_ptr<ui::Layer> root_layer_;
+#endif
 
 #if defined(OS_WIN)
   std::unique_ptr<gfx::WindowImpl> window_;

libcef/browser/osr/render_widget_host_view_osr_mac.mm

@@ -63,7 +63,7 @@ class AcceleratedWidgetMacNSViewHelper : public ui::AcceleratedWidgetMacNSView {
 ui::AcceleratedWidgetMac* CefRenderWidgetHostViewOSR::GetAcceleratedWidgetMac()
     const {
   if (browser_compositor_)
-    return browser_compositor_->accelerated_widget_mac();
+    return browser_compositor_->GetAcceleratedWidgetMac();
   return nullptr;
 }
 
@@ -307,6 +307,19 @@ void CefRenderWidgetHostViewOSR::DestroyNSTextInputOSR() {
   text_input_context_osr_mac_ = NULL;
 }
 
+ui::Compositor* CefRenderWidgetHostViewOSR::GetCompositor() const {
+  return browser_compositor_->GetCompositor();
+}
+
+content::DelegatedFrameHost* CefRenderWidgetHostViewOSR::GetDelegatedFrameHost()
+    const {
+  return browser_compositor_->GetDelegatedFrameHost();
+}
+
+ui::Layer* CefRenderWidgetHostViewOSR::GetRootLayer() const {
+  return browser_compositor_->GetRootLayer();
+}
+
 void CefRenderWidgetHostViewOSR::PlatformCreateCompositorWidget() {
   // Create a borderless non-visible 1x1 window.
   window_ = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 1, 1)
@@ -321,39 +334,23 @@ void CefRenderWidgetHostViewOSR::PlatformCreateCompositorWidget() {
   [content_view setLayer:background_layer_];
   [content_view setWantsLayer:YES];
 
-  browser_compositor_ = content::BrowserCompositorMac::Create();
   accelerated_widget_helper_ = new AcceleratedWidgetMacNSViewHelper(this);
-
-  compositor_.reset(browser_compositor_->compositor());
-  compositor_->SetRootLayer(root_layer_.get());
-  browser_compositor_->accelerated_widget_mac()->SetNSView(
-      accelerated_widget_helper_);
-  browser_compositor_->compositor()->SetVisible(true);
-
-  // CEF needs the browser compositor to remain responsive whereas normal
-  // rendering on OS X does not. This effectively reverts the changes from
-  // https://crbug.com/463988#c6
-  compositor_->SetLocksWillTimeOut(true);
-  browser_compositor_->Unsuspend();
+  browser_compositor_.reset(new content::BrowserCompositorMac(
+      accelerated_widget_helper_, this, render_widget_host_->is_hidden(),
+      true));
 }
 
 void CefRenderWidgetHostViewOSR::PlatformDestroyCompositorWidget() {
   DCHECK(window_);
 
-  // Compositor is owned by and will be freed by BrowserCompositorMac.
-  ui::Compositor* compositor = compositor_.release();
-  ALLOW_UNUSED_LOCAL(compositor);
+  browser_compositor_->Destroy();
 
   [window_ close];
   window_ = nil;
   [background_layer_ release];
   background_layer_ = nil;
 
-  browser_compositor_->accelerated_widget_mac()->ResetNSView();
-  browser_compositor_->compositor()->SetVisible(false);
-  browser_compositor_->compositor()->SetScaleAndSize(1.0, gfx::Size(0, 0));
-  browser_compositor_->compositor()->SetRootLayer(NULL);
-  content::BrowserCompositorMac::Recycle(std::move(browser_compositor_));
+  browser_compositor_.reset();
 
   delete accelerated_widget_helper_;
   accelerated_widget_helper_ = nullptr;

libcef/browser/printing/print_view_manager_base.cc

@@ -11,6 +11,7 @@
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -428,7 +429,7 @@ bool PrintViewManagerBase::RunInnerMessageLoop() {
   {
     base::MessageLoop::ScopedNestableTaskAllower allow(
         base::MessageLoop::current());
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
   }
 
   bool success = true;

libcef/browser/resource_context.cc

@@ -54,7 +54,8 @@ net::URLRequestContext* CefResourceContext::GetRequestContext() {
   return getter_->GetURLRequestContext();
 }
 
-std::unique_ptr<net::ClientCertStore> CefResourceContext::CreateClientCertStore() {
+std::unique_ptr<net::ClientCertStore>
+    CefResourceContext::CreateClientCertStore() {
 #if defined(USE_NSS_CERTS)
   return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
       net::ClientCertStoreNSS::PasswordDelegateFactory()));

libcef/browser/resource_context.h

@@ -10,6 +10,7 @@
 
 #include "content/public/browser/resource_context.h"
 #include "extensions/browser/info_map.h"
+#include "net/ssl/client_cert_store.h"
 
 class CefURLRequestContextGetter;
 
@@ -31,7 +32,8 @@ class CefResourceContext : public content::ResourceContext {
   // ResourceContext implementation.
   net::HostResolver* GetHostResolver() override;
   net::URLRequestContext* GetRequestContext() override;
-  std::unique_ptr<net::ClientCertStore> CreateClientCertStore() override;
+
+  std::unique_ptr<net::ClientCertStore> CreateClientCertStore();
 
   void set_url_request_context_getter(
       scoped_refptr<CefURLRequestContextGetter> getter);

libcef/browser/resource_dispatcher_host_delegate.cc

@@ -208,3 +208,10 @@ void CefResourceDispatcherHostDelegate::OnRequestRedirected(
     response->head.headers->AddHeader("Access-Control-Allow-Credentials: true");
   }
 }
+
+std::unique_ptr<net::ClientCertStore>
+    CefResourceDispatcherHostDelegate::CreateClientCertStore(
+        content::ResourceContext* resource_context) {
+  return static_cast<CefResourceContext*>(resource_context)->
+      CreateClientCertStore();
+}

libcef/browser/resource_dispatcher_host_delegate.h

@@ -42,6 +42,8 @@ class CefResourceDispatcherHostDelegate
       net::URLRequest* request,
       content::ResourceContext* resource_context,
       content::ResourceResponse* response) override;
+  std::unique_ptr<net::ClientCertStore> CreateClientCertStore(
+      content::ResourceContext* resource_context) override;
 
  private:
   struct StreamTargetInfo {

libcef/browser/views/textfield_impl.cc

@@ -162,7 +162,7 @@ bool CefTextfieldImpl::IsCommandEnabled(int command_id) {
 void CefTextfieldImpl::ExecuteCommand(int command_id) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   if (root_view()->IsCommandIdEnabled(command_id))
-    root_view()->ExecuteCommand(command_id);
+    root_view()->ExecuteCommand(command_id, ui::EF_NONE);
 }
 
 void CefTextfieldImpl::ClearEditHistory() {