Update OSR code

atom/browser/api/atom_api_web_contents.cc

@@ -784,9 +784,8 @@ content::JavaScriptDialogManager* WebContents::GetJavaScriptDialogManager(
   return dialog_manager_.get();
 }
 
-void WebContents::ResizeDueToAutoResize(
+void WebContents::ResizeDueToAutoResize(content::WebContents* web_contents,
-    content::WebContents* web_contents,
+                                        const gfx::Size& new_size) {
-    const gfx::Size& new_size) {
   if (IsGuest()) {
     guest_delegate_->ResizeDueToAutoResize(new_size);
   }
@@ -1613,7 +1612,13 @@ void WebContents::SendInputEvent(v8::Isolate* isolate,
   if (blink::WebInputEvent::IsMouseEventType(type)) {
     blink::WebMouseEvent mouse_event;
     if (mate::ConvertFromV8(isolate, input_event, &mouse_event)) {
-      rwh->ForwardMouseEvent(mouse_event);
+      if (IsOffScreen()) {
+#if defined(ENABLE_OSR)
+        GetOffScreenRenderWidgetHostView()->SendMouseEvent(mouse_event);
+#endif
+      } else {
+        rwh->ForwardMouseEvent(mouse_event);
+      }
       return;
     }
   } else if (blink::WebInputEvent::IsKeyboardEventType(type)) {
@@ -1627,7 +1632,14 @@ void WebContents::SendInputEvent(v8::Isolate* isolate,
   } else if (type == blink::WebInputEvent::kMouseWheel) {
     blink::WebMouseWheelEvent mouse_wheel_event;
     if (mate::ConvertFromV8(isolate, input_event, &mouse_wheel_event)) {
-      rwh->ForwardWheelEvent(mouse_wheel_event);
+      if (IsOffScreen()) {
+#if defined(ENABLE_OSR)
+        GetOffScreenRenderWidgetHostView()->SendMouseWheelEvent(
+            mouse_wheel_event);
+#endif
+      } else {
+        rwh->ForwardWheelEvent(mouse_wheel_event);
+      }
       return;
     }
   }
@@ -1823,8 +1835,7 @@ int WebContents::GetFrameRate() const {
 void WebContents::Invalidate() {
   if (IsOffScreen()) {
 #if defined(ENABLE_OSR)
-    auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
+    auto* osr_rwhv = GetOffScreenRenderWidgetHostView();
-        web_contents()->GetRenderWidgetHostView());
     if (osr_rwhv)
       osr_rwhv->Invalidate();
 #endif

atom/browser/api/atom_api_web_contents.h

@@ -51,6 +51,7 @@ class FrameSubscriber;
 
 #if defined(ENABLE_OSR)
 class OffScreenWebContentsView;
+class OffScreenRenderWidgetHostView;
 #endif
 
 namespace api {
@@ -402,6 +403,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
 #if defined(ENABLE_OSR)
   OffScreenWebContentsView* GetOffScreenWebContentsView() const;
+  OffScreenRenderWidgetHostView* GetOffScreenRenderWidgetHostView() const;
 #endif
 
   // Called when we receive a CursorChange message from chromium.

atom/browser/api/atom_api_web_contents_osr.cc

@@ -4,6 +4,7 @@
 
 #include "atom/browser/api/atom_api_web_contents.h"
 
+#include "atom/browser/osr/osr_render_widget_host_view.h"
 #include "atom/browser/osr/osr_web_contents_view.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 
@@ -21,6 +22,12 @@ OffScreenWebContentsView* WebContents::GetOffScreenWebContentsView() const {
   return static_cast<OffScreenWebContentsView*>(impl->GetView());
 }
 
+OffScreenRenderWidgetHostView* WebContents::GetOffScreenRenderWidgetHostView()
+    const {
+  return static_cast<OffScreenRenderWidgetHostView*>(
+      web_contents()->GetRenderWidgetHostView());
+}
+
 }  // namespace api
 
 }  // namespace atom

atom/browser/osr/osr_render_widget_host_view.cc

@@ -14,6 +14,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
+#include "components/viz/common/features.h"
 #include "components/viz/common/frame_sinks/copy_output_request.h"
 #include "components/viz/common/frame_sinks/delay_based_time_source.h"
 #include "components/viz/common/gl_helper.h"
@@ -21,10 +22,10 @@
 #include "content/browser/renderer_host/compositor_resize_lock.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
-#include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/context_factory.h"
+#include "content/public/browser/render_process_host.h"
 #include "media/base/video_frame.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/compositor/compositor.h"
@@ -133,7 +134,7 @@ class AtomCopyFrameGenerator {
             &AtomCopyFrameGenerator::CopyFromCompositingSurfaceHasResult,
             weak_ptr_factory_.GetWeakPtr(), damage_rect));
 
-    request->set_area(gfx::Rect(view_->GetPhysicalBackingSize()));
+    request->set_area(gfx::Rect(view_->GetCompositorViewportPixelSize()));
     view_->GetRootLayer()->RequestCopyOfOutput(std::move(request));
   }
 
@@ -269,13 +270,18 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
 #if !defined(OS_MACOSX)
   delegated_frame_host_ = std::make_unique<content::DelegatedFrameHost>(
       AllocateFrameSinkId(is_guest_view_hack), this,
-      false /* enable_surface_synchronization */);
+      features::IsSurfaceSynchronizationEnabled(),
+      base::FeatureList::IsEnabled(features::kVizDisplayCompositor),
+      true /* should_register_frame_sink_id */);
 
   root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
 #endif
 
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
 
+  // Surface synchronization is not supported with OSR.
+  DCHECK(!features::IsSurfaceSynchronizationEnabled());
+
 #if defined(OS_MACOSX)
   CreatePlatformWidget(is_guest_view_hack);
 #else
@@ -288,7 +294,7 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
       new ui::Compositor(context_factory_private->AllocateFrameSinkId(),
                          content::GetContextFactory(), context_factory_private,
                          base::ThreadTaskRunnerHandle::Get(),
-                         false /* enable_surface_synchronization */,
+                         features::IsSurfaceSynchronizationEnabled(),
                          false /* enable_pixel_canvas */));
   compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
   compositor_->SetRootLayer(root_layer_.get());
@@ -369,19 +375,6 @@ void OffScreenRenderWidgetHostView::SendBeginFrame(
     renderer_compositor_frame_sink_->OnBeginFrame(begin_frame_args);
 }
 
-bool OffScreenRenderWidgetHostView::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(OffScreenRenderWidgetHostView, message)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrames, SetNeedsBeginFrames)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  if (!handled)
-    return content::RenderWidgetHostViewBase::OnMessageReceived(message);
-  return handled;
-}
-
 void OffScreenRenderWidgetHostView::InitAsChild(gfx::NativeView) {
   DCHECK(parent_host_view_);
 
@@ -396,11 +389,6 @@ void OffScreenRenderWidgetHostView::InitAsChild(gfx::NativeView) {
   Show();
 }
 
-content::RenderWidgetHost* OffScreenRenderWidgetHostView::GetRenderWidgetHost()
-    const {
-  return render_widget_host_;
-}
-
 void OffScreenRenderWidgetHostView::SetSize(const gfx::Size& size) {
   size_ = size;
   WasResized();
@@ -447,7 +435,8 @@ void OffScreenRenderWidgetHostView::Show() {
   browser_compositor_->SetRenderWidgetHostIsHidden(false);
 #else
   delegated_frame_host_->SetCompositor(compositor_.get());
-  delegated_frame_host_->WasShown(ui::LatencyInfo());
+  delegated_frame_host_->WasShown(
+      GetLocalSurfaceId(), GetRootLayer()->bounds().size(), ui::LatencyInfo());
 #endif
 
   if (render_widget_host_)
@@ -520,7 +509,8 @@ void OffScreenRenderWidgetHostView::DidCreateNewRendererCompositorFrameSink(
 
 void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
     const viz::LocalSurfaceId& local_surface_id,
-    viz::CompositorFrame frame) {
+    viz::CompositorFrame frame,
+    viz::mojom::HitTestRegionListPtr hit_test_region_list) {
   TRACE_EVENT0("electron",
                "OffScreenRenderWidgetHostView::SubmitCompositorFrame");
 
@@ -539,8 +529,8 @@ void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
       // We would normally call BrowserCompositorMac::SubmitCompositorFrame on
       // macOS, however it contains compositor resize logic that we don't want.
       // Consequently we instead call the SubmitCompositorFrame method directly.
-      GetDelegatedFrameHost()->SubmitCompositorFrame(local_surface_id,
+      GetDelegatedFrameHost()->SubmitCompositorFrame(
-                                                     std::move(frame));
+          local_surface_id, std::move(frame), std::move(hit_test_region_list));
     } else {
       if (!copy_frame_generator_.get()) {
         copy_frame_generator_.reset(
@@ -558,8 +548,8 @@ void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
       // We would normally call BrowserCompositorMac::SubmitCompositorFrame on
       // macOS, however it contains compositor resize logic that we don't want.
       // Consequently we instead call the SubmitCompositorFrame method directly.
-      GetDelegatedFrameHost()->SubmitCompositorFrame(local_surface_id,
+      GetDelegatedFrameHost()->SubmitCompositorFrame(
-                                                     std::move(frame));
+          local_surface_id, std::move(frame), std::move(hit_test_region_list));
 
       // Request a copy of the last compositor frame which will eventually call
       // OnPaint asynchronously.
@@ -645,20 +635,23 @@ void OffScreenRenderWidgetHostView::SelectionBoundsChanged(
     const ViewHostMsg_SelectionBounds_Params&) {}
 
 void OffScreenRenderWidgetHostView::CopyFromSurface(
-    const gfx::Rect& src_subrect,
+    const gfx::Rect& src_rect,
-    const gfx::Size& dst_size,
+    const gfx::Size& output_size,
-    const content::ReadbackRequestCallback& callback,
+    base::OnceCallback<void(const SkBitmap&)> callback) {
-    const SkColorType preferred_color_type) {
+  GetDelegatedFrameHost()->CopyFromCompositingSurface(src_rect, output_size,
-  GetDelegatedFrameHost()->CopyFromCompositingSurface(
+                                                      std::move(callback));
-      src_subrect, dst_size, callback, preferred_color_type);
 }
 
-void OffScreenRenderWidgetHostView::CopyFromSurfaceToVideoFrame(
+void OffScreenRenderWidgetHostView::GetScreenInfo(
-    const gfx::Rect& src_subrect,
+    content::ScreenInfo* screen_info) const {
-    scoped_refptr<media::VideoFrame> target,
+  screen_info->depth = 24;
-    const base::Callback<void(const gfx::Rect&, bool)>& callback) {
+  screen_info->depth_per_component = 8;
-  GetDelegatedFrameHost()->CopyFromCompositingSurfaceToVideoFrame(
+  screen_info->orientation_angle = 0;
-      src_subrect, target, callback);
+  screen_info->device_scale_factor = 1.0;
+  screen_info->orientation_type =
+      content::SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
+  screen_info->rect = gfx::Rect(size_);
+  screen_info->available_rect = gfx::Rect(size_);
 }
 
 void OffScreenRenderWidgetHostView::InitAsGuest(
@@ -668,19 +661,31 @@ void OffScreenRenderWidgetHostView::InitAsGuest(
   parent_host_view_->RegisterGuestViewFrameSwappedCallback(guest_view);
 }
 
-bool OffScreenRenderWidgetHostView::HasAcceleratedSurface(const gfx::Size&) {
+gfx::Vector2d OffScreenRenderWidgetHostView::GetOffsetFromRootSurface() {
-  return false;
+  return gfx::Vector2d();
 }
 
 gfx::Rect OffScreenRenderWidgetHostView::GetBoundsInRootWindow() {
   return gfx::Rect(size_);
 }
 
+content::RenderWidgetHostImpl*
+OffScreenRenderWidgetHostView::GetRenderWidgetHostImpl() const {
+  return render_widget_host_;
+}
+
+viz::SurfaceId OffScreenRenderWidgetHostView::GetCurrentSurfaceId() const {
+  return GetDelegatedFrameHost()
+             ? GetDelegatedFrameHost()->GetCurrentSurfaceId()
+             : viz::SurfaceId();
+}
+
 void OffScreenRenderWidgetHostView::ImeCompositionRangeChanged(
     const gfx::Range&,
     const std::vector<gfx::Rect>&) {}
 
-gfx::Size OffScreenRenderWidgetHostView::GetPhysicalBackingSize() const {
+gfx::Size OffScreenRenderWidgetHostView::GetCompositorViewportPixelSize()
+    const {
   return gfx::ScaleToCeiledSize(GetRequestedRendererSize(), scale_factor_);
 }
 
@@ -718,18 +723,13 @@ bool OffScreenRenderWidgetHostView::DelegatedFrameHostIsVisible() const {
   return !render_widget_host_->is_hidden();
 }
 
-SkColor OffScreenRenderWidgetHostView::DelegatedFrameHostGetGutterColor(
+SkColor OffScreenRenderWidgetHostView::DelegatedFrameHostGetGutterColor()
-    SkColor color) const {
+    const {
   if (render_widget_host_->delegate() &&
       render_widget_host_->delegate()->IsFullscreenForCurrentTab()) {
     return SK_ColorWHITE;
   }
-  return color;
+  return background_color_;
-}
-
-gfx::Size OffScreenRenderWidgetHostView::DelegatedFrameHostDesiredSizeInDIP()
-    const {
-  return GetRootLayer()->bounds().size();
 }
 
 bool OffScreenRenderWidgetHostView::DelegatedFrameCanCreateResizeLock() const {
@@ -747,7 +747,18 @@ viz::LocalSurfaceId OffScreenRenderWidgetHostView::GetLocalSurfaceId() const {
   return local_surface_id_;
 }
 
-void OffScreenRenderWidgetHostView::OnBeginFrame() {}
+void OffScreenRenderWidgetHostView::OnFirstSurfaceActivation(
+    const viz::SurfaceInfo& surface_info) {}
+
+void OffScreenRenderWidgetHostView::OnBeginFrame(base::TimeTicks frame_time) {}
+
+void OffScreenRenderWidgetHostView::OnFrameTokenChanged(uint32_t frame_token) {
+  render_widget_host_->DidProcessFrame(frame_token);
+}
+
+void OffScreenRenderWidgetHostView::DidReceiveFirstFrameAfterNavigation() {
+  render_widget_host_->DidReceiveFirstFrameAfterNavigation();
+}
 
 std::unique_ptr<ui::CompositorLock>
 OffScreenRenderWidgetHostView::GetCompositorLock(
@@ -766,12 +777,12 @@ bool OffScreenRenderWidgetHostView::IsAutoResizeEnabled() const {
 #endif  // !defined(OS_MACOSX)
 
 bool OffScreenRenderWidgetHostView::TransformPointToLocalCoordSpace(
-    const gfx::Point& point,
+    const gfx::PointF& point,
     const viz::SurfaceId& original_surface,
-    gfx::Point* transformed_point) {
+    gfx::PointF* transformed_point) {
   // Transformations use physical pixels rather than DIP, so conversion
   // is necessary.
-  gfx::Point point_in_pixels = gfx::ConvertPointToPixel(scale_factor_, point);
+  gfx::PointF point_in_pixels = gfx::ConvertPointToPixel(scale_factor_, point);
   if (!GetDelegatedFrameHost()->TransformPointToLocalCoordSpace(
           point_in_pixels, original_surface, transformed_point)) {
     return false;
@@ -783,9 +794,9 @@ bool OffScreenRenderWidgetHostView::TransformPointToLocalCoordSpace(
 }
 
 bool OffScreenRenderWidgetHostView::TransformPointToCoordSpaceForView(
-    const gfx::Point& point,
+    const gfx::PointF& point,
     RenderWidgetHostViewBase* target_view,
-    gfx::Point* transformed_point) {
+    gfx::PointF* transformed_point) {
   if (target_view == this) {
     *transformed_point = point;
     return true;
@@ -851,10 +862,9 @@ void OffScreenRenderWidgetHostView::ProxyViewDestroyed(
 
 void OffScreenRenderWidgetHostView::RegisterGuestViewFrameSwappedCallback(
     content::RenderWidgetHostViewGuest* guest_host_view) {
-  guest_host_view->RegisterFrameSwappedCallback(
+  guest_host_view->RegisterFrameSwappedCallback(base::BindOnce(
-      std::make_unique<base::Closure>(base::Bind(
+      &OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped,
-          &OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped,
+      weak_ptr_factory_.GetWeakPtr(), base::Unretained(guest_host_view)));
-          weak_ptr_factory_.GetWeakPtr(), base::Unretained(guest_host_view))));
 }
 
 void OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped(
@@ -904,6 +914,12 @@ void OffScreenRenderWidgetHostView::SetNeedsBeginFrames(
   }
 }
 
+void OffScreenRenderWidgetHostView::SetWantsAnimateOnlyBeginFrames() {
+  if (GetDelegatedFrameHost()) {
+    GetDelegatedFrameHost()->SetWantsAnimateOnlyBeginFrames();
+  }
+}
+
 void CopyBitmapTo(const SkBitmap& destination,
                   const SkBitmap& source,
                   const gfx::Rect& pos) {
@@ -1021,20 +1037,12 @@ void OffScreenRenderWidgetHostView::WasResized() {
   ResizeRootLayer();
   if (render_widget_host_)
     render_widget_host_->WasResized();
-  GetDelegatedFrameHost()->WasResized();
+  GetDelegatedFrameHost()->WasResized(local_surface_id_, size_,
+                                      cc::DeadlinePolicy::UseDefaultDeadline());
 }
 
-void OffScreenRenderWidgetHostView::ProcessKeyboardEvent(
+void OffScreenRenderWidgetHostView::SendMouseEvent(
-    const content::NativeWebKeyboardEvent& event,
+    const blink::WebMouseEvent& event) {
-    const ui::LatencyInfo& latency) {
-  if (!render_widget_host_)
-    return;
-  render_widget_host_->ForwardKeyboardEventWithLatencyInfo(event, latency);
-}
-
-void OffScreenRenderWidgetHostView::ProcessMouseEvent(
-    const blink::WebMouseEvent& event,
-    const ui::LatencyInfo& latency) {
   for (auto* proxy_view : proxy_views_) {
     gfx::Rect bounds = proxy_view->GetBounds();
     if (bounds.Contains(event.PositionInWidget().x,
@@ -1061,7 +1069,7 @@ void OffScreenRenderWidgetHostView::ProcessMouseEvent(
           popup_event.PositionInWidget().y -
               popup_host_view_->popup_position_.y());
 
-      popup_host_view_->ProcessMouseEvent(popup_event, latency);
+      popup_host_view_->ProcessMouseEvent(popup_event, ui::LatencyInfo());
       return;
     }
   }
@@ -1071,9 +1079,8 @@ void OffScreenRenderWidgetHostView::ProcessMouseEvent(
   render_widget_host_->ForwardMouseEvent(event);
 }
 
-void OffScreenRenderWidgetHostView::ProcessMouseWheelEvent(
+void OffScreenRenderWidgetHostView::SendMouseWheelEvent(
-    const blink::WebMouseWheelEvent& event,
+    const blink::WebMouseWheelEvent& event) {
-    const ui::LatencyInfo& latency) {
   for (auto* proxy_view : proxy_views_) {
     gfx::Rect bounds = proxy_view->GetBounds();
     if (bounds.Contains(event.PositionInWidget().x,
@@ -1099,7 +1106,8 @@ void OffScreenRenderWidgetHostView::ProcessMouseWheelEvent(
                 popup_host_view_->popup_position_.x(),
             popup_event.PositionInWidget().y -
                 popup_host_view_->popup_position_.y());
-        popup_host_view_->ProcessMouseWheelEvent(popup_event, latency);
+        popup_host_view_->ProcessMouseWheelEvent(popup_event,
+                                                 ui::LatencyInfo());
         return;
       } else {
         // Scrolling outside of the popup widget so destroy it.
@@ -1226,7 +1234,21 @@ void OffScreenRenderWidgetHostView::ResizeRootLayer() {
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
 
   GetRootLayer()->SetBounds(gfx::Rect(size));
-  GetCompositor()->SetScaleAndSize(scale_factor_, size_in_pixels);
+  GetCompositor()->SetScaleAndSize(scale_factor_, size_in_pixels,
+                                   local_surface_id_);
+
+#if defined(OS_MACOSX)
+  bool resized = browser_compositor_->UpdateNSViewAndDisplay();
+#else
+  bool resized = true;
+  GetDelegatedFrameHost()->WasResized(local_surface_id_, size,
+                                      cc::DeadlinePolicy::UseDefaultDeadline());
+#endif
+
+  // Note that |render_widget_host_| will retrieve resize parameters from the
+  // DelegatedFrameHost, so it must have WasResized called after.
+  if (resized && render_widget_host_)
+    render_widget_host_->WasResized();
 }
 
 viz::FrameSinkId OffScreenRenderWidgetHostView::AllocateFrameSinkId(

atom/browser/osr/osr_render_widget_host_view.h

@@ -85,9 +85,7 @@ class OffScreenRenderWidgetHostView
   ~OffScreenRenderWidgetHostView() override;
 
   // content::RenderWidgetHostView:
-  bool OnMessageReceived(const IPC::Message&) override;
   void InitAsChild(gfx::NativeView) override;
-  content::RenderWidgetHost* GetRenderWidgetHost(void) const override;
   void SetSize(const gfx::Size&) override;
   void SetBounds(const gfx::Rect&) override;
   gfx::Vector2dF GetLastScrollOffset(void) const override;
@@ -108,6 +106,7 @@ class OffScreenRenderWidgetHostView
   bool LockMouse(void) override;
   void UnlockMouse(void) override;
   void SetNeedsBeginFrames(bool needs_begin_frames) override;
+  void SetWantsAnimateOnlyBeginFrames() override;
 #if defined(OS_MACOSX)
   ui::AcceleratedWidgetMac* GetAcceleratedWidgetMac() const override;
   void SetActive(bool active) override;
@@ -122,8 +121,10 @@ class OffScreenRenderWidgetHostView
   void DidCreateNewRendererCompositorFrameSink(
       viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink)
       override;
-  void SubmitCompositorFrame(const viz::LocalSurfaceId& local_surface_id,
+  void SubmitCompositorFrame(
-                             viz::CompositorFrame frame) override;
+      const viz::LocalSurfaceId& local_surface_id,
+      viz::CompositorFrame frame,
+      viz::mojom::HitTestRegionListPtr hit_test_region_list) override;
 
   void ClearCompositorFrame(void) override;
   void InitAsPopup(content::RenderWidgetHostView* rwhv,
@@ -136,28 +137,22 @@ class OffScreenRenderWidgetHostView
   void RenderProcessGone(base::TerminationStatus, int) override;
   void Destroy(void) override;
   void SetTooltipText(const base::string16&) override;
-#if defined(OS_MACOSX)
-  void SelectionChanged(const base::string16& text,
-                        size_t offset,
-                        const gfx::Range& range) override;
-#endif
   void SelectionBoundsChanged(
       const ViewHostMsg_SelectionBounds_Params&) override;
-  void CopyFromSurface(const gfx::Rect& src_subrect,
+  void CopyFromSurface(
-                       const gfx::Size& dst_size,
+      const gfx::Rect& src_rect,
-                       const content::ReadbackRequestCallback& callback,
+      const gfx::Size& output_size,
-                       const SkColorType color_type) override;
+      base::OnceCallback<void(const SkBitmap&)> callback) override;
-  void CopyFromSurfaceToVideoFrame(
+  void GetScreenInfo(content::ScreenInfo* results) const override;
-      const gfx::Rect& src_subrect,
-      scoped_refptr<media::VideoFrame> target,
-      const base::Callback<void(const gfx::Rect&, bool)>& callback) override;
   void InitAsGuest(content::RenderWidgetHostView*,
                    content::RenderWidgetHostViewGuest*) override;
-  bool HasAcceleratedSurface(const gfx::Size&) override;
+  gfx::Vector2d GetOffsetFromRootSurface() override;
   gfx::Rect GetBoundsInRootWindow(void) override;
+  content::RenderWidgetHostImpl* GetRenderWidgetHostImpl() const override;
+  viz::SurfaceId GetCurrentSurfaceId() const override;
   void ImeCompositionRangeChanged(const gfx::Range&,
                                   const std::vector<gfx::Rect>&) override;
-  gfx::Size GetPhysicalBackingSize() const override;
+  gfx::Size GetCompositorViewportPixelSize() const override;
   gfx::Size GetRequestedRendererSize() const override;
 
   content::RenderWidgetHostViewBase* CreateViewForWidget(
@@ -170,13 +165,15 @@ class OffScreenRenderWidgetHostView
   int DelegatedFrameHostGetGpuMemoryBufferClientId(void) const;
   ui::Layer* DelegatedFrameHostGetLayer(void) const override;
   bool DelegatedFrameHostIsVisible(void) const override;
-  SkColor DelegatedFrameHostGetGutterColor(SkColor) const override;
+  SkColor DelegatedFrameHostGetGutterColor() const override;
-  gfx::Size DelegatedFrameHostDesiredSizeInDIP(void) const override;
   bool DelegatedFrameCanCreateResizeLock() const override;
   std::unique_ptr<content::CompositorResizeLock>
   DelegatedFrameHostCreateResizeLock() override;
   viz::LocalSurfaceId GetLocalSurfaceId() const override;
-  void OnBeginFrame() override;
+  void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;
+  void OnBeginFrame(base::TimeTicks frame_time) override;
+  void OnFrameTokenChanged(uint32_t frame_token) override;
+  void DidReceiveFirstFrameAfterNavigation() override;
   // CompositorResizeLockClient implementation.
   std::unique_ptr<ui::CompositorLock> GetCompositorLock(
       ui::CompositorLockClient* client) override;
@@ -184,13 +181,13 @@ class OffScreenRenderWidgetHostView
   bool IsAutoResizeEnabled() const override;
 #endif  // !defined(OS_MACOSX)
 
-  bool TransformPointToLocalCoordSpace(const gfx::Point& point,
+  bool TransformPointToLocalCoordSpace(const gfx::PointF& point,
                                        const viz::SurfaceId& original_surface,
-                                       gfx::Point* transformed_point) override;
+                                       gfx::PointF* transformed_point) override;
   bool TransformPointToCoordSpaceForView(
-      const gfx::Point& point,
+      const gfx::PointF& point,
       RenderWidgetHostViewBase* target_view,
-      gfx::Point* transformed_point) override;
+      gfx::PointF* transformed_point) override;
 
   // ui::CompositorDelegate:
   std::unique_ptr<viz::SoftwareOutputDevice> CreateSoftwareOutputDevice(
@@ -232,12 +229,8 @@ class OffScreenRenderWidgetHostView
   void ReleaseResize();
   void WasResized();
 
-  void ProcessKeyboardEvent(const content::NativeWebKeyboardEvent& event,
+  void SendMouseEvent(const blink::WebMouseEvent& event);
-                            const ui::LatencyInfo& latency) override;
+  void SendMouseWheelEvent(const blink::WebMouseWheelEvent& event);
-  void ProcessMouseEvent(const blink::WebMouseEvent& event,
-                         const ui::LatencyInfo& latency) override;
-  void ProcessMouseWheelEvent(const blink::WebMouseWheelEvent& event,
-                              const ui::LatencyInfo& latency) override;
 
   void SetPainting(bool painting);
   bool IsPainting() const;
@@ -330,7 +323,6 @@ class OffScreenRenderWidgetHostView
   uint64_t begin_frame_number_ = viz::BeginFrameArgs::kStartingFrameNumber;
 
 #if defined(OS_MACOSX)
-  CALayer* background_layer_;
   std::unique_ptr<content::BrowserCompositorMac> browser_compositor_;
 
   // Can not be managed by smart pointer because its header can not be included

atom/browser/osr/osr_render_widget_host_view_mac.mm

@@ -22,13 +22,6 @@ class MacHelper : public content::BrowserCompositorMacClient,
   virtual ~MacHelper() {}
 
   // content::BrowserCompositorMacClient:
-  NSView* BrowserCompositorMacGetNSView() const override {
-    // Intentionally return nil so that
-    // BrowserCompositorMac::DelegatedFrameHostDesiredSizeInDIP uses the layer
-    // size instead of the NSView size.
-    return nil;
-  }
-
   SkColor BrowserCompositorMacGetGutterColor(SkColor color) const override {
     // When making an element on the page fullscreen the element's background
     // may not match the page's, so use black as the gutter color to avoid
@@ -42,8 +35,8 @@ class MacHelper : public content::BrowserCompositorMacClient,
 
   void BrowserCompositorMacOnBeginFrame() override {}
 
-  viz::LocalSurfaceId GetLocalSurfaceId() const override {
+  void OnFrameTokenChanged(uint32_t frame_token) override {
-    return view_->local_surface_id();
+    view_->render_widget_host()->DidProcessFrame(frame_token);
   }
 
   // ui::AcceleratedWidgetMacNSView:
@@ -60,19 +53,18 @@ class MacHelper : public content::BrowserCompositorMacClient,
 
   void AcceleratedWidgetSwapCompleted() override {}
 
+  void DidReceiveFirstFrameAfterNavigation() override {
+    view_->render_widget_host()->DidReceiveFirstFrameAfterNavigation();
+  }
+
+  void DestroyCompositorForShutdown() override {}
+
  private:
   OffScreenRenderWidgetHostView* view_;
 
   DISALLOW_COPY_AND_ASSIGN(MacHelper);
 };
 
-ui::AcceleratedWidgetMac*
-OffScreenRenderWidgetHostView::GetAcceleratedWidgetMac() const {
-  if (browser_compositor_)
-    return browser_compositor_->GetAcceleratedWidgetMac();
-  return nullptr;
-}
-
 void OffScreenRenderWidgetHostView::SetActive(bool active) {}
 
 void OffScreenRenderWidgetHostView::ShowDefinitionForSelection() {}
@@ -89,24 +81,8 @@ bool OffScreenRenderWidgetHostView::IsSpeaking() const {
 
 void OffScreenRenderWidgetHostView::StopSpeaking() {}
 
-void OffScreenRenderWidgetHostView::SelectionChanged(const base::string16& text,
+bool CefRenderWidgetHostViewOSR::ShouldContinueToPauseForFrame() {
-                                                     size_t offset,
+  return browser_compositor_->ShouldContinueToPauseForFrame();
-                                                     const gfx::Range& range) {
-  if (range.is_empty() || text.empty()) {
-    selected_text_.clear();
-  } else {
-    size_t pos = range.GetMin() - offset;
-    size_t n = range.length();
-
-    DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
-    if (pos >= text.length()) {
-      DCHECK(false) << "The text can not cover range.";
-      return;
-    }
-    selected_text_ = base::UTF16ToUTF8(text.substr(pos, n));
-  }
-
-  RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 }
 
 void OffScreenRenderWidgetHostView::CreatePlatformWidget(

atom/browser/osr/osr_web_contents_view.cc

@@ -80,6 +80,8 @@ void OffScreenWebContentsView::StoreFocus() {}
 
 void OffScreenWebContentsView::RestoreFocus() {}
 
+void OffScreenWebContentsView::FocusThroughTabTraversal(bool reverse) {}
+
 content::DropData* OffScreenWebContentsView::GetDropData() const {
   return nullptr;
 }
@@ -143,26 +145,6 @@ void OffScreenWebContentsView::RenderViewSwappedIn(
 
 void OffScreenWebContentsView::SetOverscrollControllerEnabled(bool enabled) {}
 
-void OffScreenWebContentsView::GetScreenInfo(
-    content::ScreenInfo* screen_info) const {
-  screen_info->depth = 24;
-  screen_info->depth_per_component = 8;
-  screen_info->orientation_angle = 0;
-  screen_info->device_scale_factor = 1.0;
-  screen_info->orientation_type =
-      content::SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
-
-  if (GetView()) {
-    screen_info->rect = gfx::Rect(GetView()->size());
-    screen_info->available_rect = gfx::Rect(GetView()->size());
-  } else {
-    const display::Display display =
-        display::Screen::GetScreen()->GetPrimaryDisplay();
-    screen_info->rect = display.bounds();
-    screen_info->available_rect = display.work_area();
-  }
-}
-
 #if defined(OS_MACOSX)
 void OffScreenWebContentsView::SetAllowOtherViews(bool allow) {}
 

atom/browser/osr/osr_web_contents_view.h

@@ -38,6 +38,7 @@ class OffScreenWebContentsView : public content::WebContentsView,
   void SetInitialFocus() override;
   void StoreFocus() override;
   void RestoreFocus() override;
+  void FocusThroughTabTraversal(bool reverse) override;
   content::DropData* GetDropData() const override;
   gfx::Rect GetViewBounds() const override;
   void CreateView(const gfx::Size& initial_size,
@@ -51,7 +52,6 @@ class OffScreenWebContentsView : public content::WebContentsView,
   void RenderViewCreated(content::RenderViewHost* host) override;
   void RenderViewSwappedIn(content::RenderViewHost* host) override;
   void SetOverscrollControllerEnabled(bool enabled) override;
-  void GetScreenInfo(content::ScreenInfo* screen_info) const override;
 
 #if defined(OS_MACOSX)
   void SetAllowOtherViews(bool allow) override;

atom/browser/ui/autofill_popup.cc

@@ -209,9 +209,13 @@ void AutofillPopup::UpdatePopupBounds() {
   popup_bounds_ =
       gfx::Rect(popup_x_and_width.first, popup_y_and_height.first,
                 popup_x_and_width.second, popup_y_and_height.second);
-  popup_bounds_in_view_ =
+}
-      gfx::Rect(popup_bounds_in_view_.origin(),
+
-                gfx::Size(popup_x_and_width.second, popup_y_and_height.second));
+gfx::Rect AutofillPopup::popup_bounds_in_view() {
+  gfx::Point origin(popup_bounds_.origin());
+  views::View::ConvertPointFromScreen(parent_, &origin);
+
+  return gfx::Rect(origin, popup_bounds_.size());
 }
 
 void AutofillPopup::OnViewBoundsChanged(views::View* view) {

atom/browser/ui/autofill_popup.h

@@ -34,6 +34,8 @@ class AutofillPopup : public views::ViewObserver {
                 const std::vector<base::string16>& labels);
   void UpdatePopupBounds();
 
+  gfx::Rect popup_bounds_in_view();
+
  private:
   friend class AutofillPopupView;
 
@@ -59,7 +61,6 @@ class AutofillPopup : public views::ViewObserver {
 
   // Popup location
   gfx::Rect popup_bounds_;
-  gfx::Rect popup_bounds_in_view_;
 
   // Bounds of the autofilled element
   gfx::Rect element_bounds_;

atom/browser/ui/views/autofill_popup_view.cc

@@ -223,6 +223,11 @@ void AutofillPopupView::DoUpdateBoundsAndRedrawPopup() {
     return;
 
   GetWidget()->SetBounds(popup_->popup_bounds_);
+#if defined(ENABLE_OSR)
+  if (view_proxy_.get()) {
+    view_proxy_->SetBounds(popup_->popup_bounds_in_view());
+  }
+#endif
   SchedulePaint();
 }
 
@@ -235,8 +240,8 @@ void AutofillPopupView::OnPaint(gfx::Canvas* canvas) {
 #if defined(ENABLE_OSR)
   std::unique_ptr<cc::SkiaPaintCanvas> paint_canvas;
   if (view_proxy_.get()) {
-    bitmap.allocN32Pixels(popup_->popup_bounds_in_view_.width(),
+    bitmap.allocN32Pixels(popup_->popup_bounds_in_view().width(),
-                          popup_->popup_bounds_in_view_.height(), true);
+                          popup_->popup_bounds_in_view().height(), true);
     paint_canvas.reset(new cc::SkiaPaintCanvas(bitmap));
     draw_canvas = new gfx::Canvas(paint_canvas.get(), 1.0);
   }
@@ -254,7 +259,7 @@ void AutofillPopupView::OnPaint(gfx::Canvas* canvas) {
 
 #if defined(ENABLE_OSR)
   if (view_proxy_.get()) {
-    view_proxy_->SetBounds(popup_->popup_bounds_in_view_);
+    view_proxy_->SetBounds(popup_->popup_bounds_in_view());
     view_proxy_->SetBitmap(bitmap);
   }
 #endif

brightray/browser/browser_main_parts.cc

@@ -181,7 +181,10 @@ void OverrideAppLogsPath() {
 int BrowserMainParts::PreEarlyInitialization() {
   std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
   // TODO(deepak1556): Disable guest webcontents based on OOPIF feature.
-  feature_list->InitializeFromCommandLine("", "GuestViewCrossProcessFrames");
+  // Disable surface synchronization and async wheel events to make OSR work.
+  feature_list->InitializeFromCommandLine(
+      "",
+      "GuestViewCrossProcessFrames,SurfaceSynchronization,AsyncWheelEvents");
   base::FeatureList::SetInstance(std::move(feature_list));
   OverrideAppLogsPath();
 #if defined(USE_X11)