fix: enable and update osr (backport: 5-0-x) (#16616)

* fix: enable OSR

* fix some macos errors

* fix client reset not in guard

* fix things not rendering on mac

atom/browser/osr/osr_render_widget_host_view.cc

@@ -252,6 +252,50 @@ class AtomBeginFrameTimer : public viz::DelayBasedTimeSourceClient {
   DISALLOW_COPY_AND_ASSIGN(AtomBeginFrameTimer);
 };
 
+#if !defined(OS_MACOSX)
+class AtomDelegatedFrameHostClient : public content::DelegatedFrameHostClient {
+ public:
+  explicit AtomDelegatedFrameHostClient(OffScreenRenderWidgetHostView* view)
+      : view_(view) {}
+
+  ui::Layer* DelegatedFrameHostGetLayer() const override {
+    return view_->GetRootLayer();
+  }
+
+  bool DelegatedFrameHostIsVisible() const override {
+    return view_->IsShowing();
+  }
+
+  SkColor DelegatedFrameHostGetGutterColor() const override {
+    if (view_->render_widget_host()->delegate() &&
+        view_->render_widget_host()->delegate()->IsFullscreenForCurrentTab()) {
+      return SK_ColorWHITE;
+    }
+    return *view_->GetBackgroundColor();
+  }
+
+  void OnFrameTokenChanged(uint32_t frame_token) override {
+    view_->render_widget_host()->DidProcessFrame(frame_token);
+  }
+
+  float GetDeviceScaleFactor() const override {
+    return view_->GetDeviceScaleFactor();
+  }
+
+  std::vector<viz::SurfaceId> CollectSurfaceIdsForEviction() override {
+    return view_->render_widget_host()->CollectSurfaceIdsForEviction();
+  }
+
+  void OnBeginFrame(base::TimeTicks frame_time) override {}
+  void InvalidateLocalSurfaceIdOnEviction() override {}
+
+ private:
+  OffScreenRenderWidgetHostView* const view_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomDelegatedFrameHostClient);
+};
+#endif  // !defined(OS_MACOSX)
+
 OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
     bool transparent,
     bool painting,
@@ -274,18 +318,22 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
       weak_ptr_factory_(this) {
   DCHECK(render_widget_host_);
   bool is_guest_view_hack = parent_host_view_ != nullptr;
+
+  current_device_scale_factor_ = kDefaultScaleFactor;
+
 #if !defined(OS_MACOSX)
+  local_surface_id_allocator_.GenerateId();
+  local_surface_id_allocation_ =
+      local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
+  delegated_frame_host_client_.reset(new AtomDelegatedFrameHostClient(this));
   delegated_frame_host_ = std::make_unique<content::DelegatedFrameHost>(
-      AllocateFrameSinkId(is_guest_view_hack), this,
+      AllocateFrameSinkId(is_guest_view_hack),
+      delegated_frame_host_client_.get(),
       true /* should_register_frame_sink_id */);
 
   root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
 #endif
 
-  current_device_scale_factor_ = kDefaultScaleFactor;
-
-  local_surface_id_ = local_surface_id_allocator_.GenerateId();
-
 #if defined(OS_MACOSX)
   last_frame_root_background_color_ = SK_ColorTRANSPARENT;
   CreatePlatformWidget(is_guest_view_hack);
@@ -374,7 +422,7 @@ void OffScreenRenderWidgetHostView::SendBeginFrame(
   begin_frame_number_++;
 
   if (renderer_compositor_frame_sink_)
-    renderer_compositor_frame_sink_->OnBeginFrame(begin_frame_args);
+    renderer_compositor_frame_sink_->OnBeginFrame(begin_frame_args, {});
 }
 
 void OffScreenRenderWidgetHostView::InitAsChild(gfx::NativeView) {
@@ -433,8 +481,9 @@ void OffScreenRenderWidgetHostView::Show() {
   browser_compositor_->SetRenderWidgetHostIsHidden(false);
 #else
   delegated_frame_host_->AttachToCompositor(compositor_.get());
-  delegated_frame_host_->WasShown(GetLocalSurfaceId(),
-                                  GetRootLayer()->bounds().size(), false);
+  delegated_frame_host_->WasShown(
+      GetLocalSurfaceIdAllocation().local_surface_id(),
+      GetRootLayer()->bounds().size(), false);
 #endif
 
   if (render_widget_host_)
@@ -525,19 +574,22 @@ void OffScreenRenderWidgetHostView::TakeFallbackContentFrom(
 void OffScreenRenderWidgetHostView::DidCreateNewRendererCompositorFrameSink(
     viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink) {
   renderer_compositor_frame_sink_ = renderer_compositor_frame_sink;
+
+#if defined(OS_MACOSX)
+  browser_compositor_->DidCreateNewRendererCompositorFrameSink(
+      renderer_compositor_frame_sink_);
+#else
   if (GetDelegatedFrameHost()) {
     GetDelegatedFrameHost()->DidCreateNewRendererCompositorFrameSink(
         renderer_compositor_frame_sink_);
   }
+#endif
 }
 
 void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
     const viz::LocalSurfaceId& local_surface_id,
     viz::CompositorFrame frame,
     base::Optional<viz::HitTestRegionList> hit_test_region_list) {
-  TRACE_EVENT0("electron",
-               "OffScreenRenderWidgetHostView::SubmitCompositorFrame");
-
 #if defined(OS_MACOSX)
   last_frame_root_background_color_ = frame.metadata.root_background_color;
 #endif
@@ -587,7 +639,7 @@ void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
 }
 
 void OffScreenRenderWidgetHostView::ClearCompositorFrame() {
-  GetDelegatedFrameHost()->ClearDelegatedFrame();
+  NOTREACHED();
 }
 
 void OffScreenRenderWidgetHostView::ResetFallbackToFirstNavigationSurface() {
@@ -667,9 +719,6 @@ void OffScreenRenderWidgetHostView::Destroy() {
 
 void OffScreenRenderWidgetHostView::SetTooltipText(const base::string16&) {}
 
-void OffScreenRenderWidgetHostView::SelectionBoundsChanged(
-    const ViewHostMsg_SelectionBounds_Params&) {}
-
 uint32_t OffScreenRenderWidgetHostView::GetCaptureSequenceNumber() const {
   return latest_capture_sequence_number_;
 }
@@ -698,7 +747,6 @@ void OffScreenRenderWidgetHostView::InitAsGuest(
     content::RenderWidgetHostView* parent_host_view,
     content::RenderWidgetHostViewGuest* guest_view) {
   parent_host_view_->AddGuestHostView(this);
-  parent_host_view_->RegisterGuestViewFrameSwappedCallback(guest_view);
 }
 
 void OffScreenRenderWidgetHostView::TransformPointToRootSurface(
@@ -745,40 +793,6 @@ OffScreenRenderWidgetHostView::CreateViewForWidget(
       render_widget_host, embedder_host_view, size());
 }
 
-#if !defined(OS_MACOSX)
-ui::Layer* OffScreenRenderWidgetHostView::DelegatedFrameHostGetLayer() const {
-  return const_cast<ui::Layer*>(root_layer_.get());
-}
-
-bool OffScreenRenderWidgetHostView::DelegatedFrameHostIsVisible() const {
-  return is_showing_;
-}
-
-SkColor OffScreenRenderWidgetHostView::DelegatedFrameHostGetGutterColor()
-    const {
-  if (render_widget_host_->delegate() &&
-      render_widget_host_->delegate()->IsFullscreenForCurrentTab()) {
-    return SK_ColorWHITE;
-  }
-  return background_color_;
-}
-
-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);
-}
-
-const viz::LocalSurfaceId& OffScreenRenderWidgetHostView::GetLocalSurfaceId()
-    const {
-  return local_surface_id_;
-}
-
-#endif  // !defined(OS_MACOSX)
-
 const viz::FrameSinkId& OffScreenRenderWidgetHostView::GetFrameSinkId() const {
   return GetDelegatedFrameHost()->frame_sink_id();
 }
@@ -875,21 +889,6 @@ void OffScreenRenderWidgetHostView::ProxyViewDestroyed(
   Invalidate();
 }
 
-void OffScreenRenderWidgetHostView::RegisterGuestViewFrameSwappedCallback(
-    content::RenderWidgetHostViewGuest* guest_host_view) {
-  guest_host_view->RegisterFrameSwappedCallback(base::BindOnce(
-      &OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped,
-      weak_ptr_factory_.GetWeakPtr(), base::Unretained(guest_host_view)));
-}
-
-void OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped(
-    content::RenderWidgetHostViewGuest* guest_host_view) {
-  InvalidateBounds(gfx::ConvertRectToPixel(current_device_scale_factor_,
-                                           guest_host_view->GetViewBounds()));
-
-  RegisterGuestViewFrameSwappedCallback(guest_host_view);
-}
-
 std::unique_ptr<viz::SoftwareOutputDevice>
 OffScreenRenderWidgetHostView::CreateSoftwareOutputDevice(
     ui::Compositor* compositor) {
@@ -925,7 +924,7 @@ void OffScreenRenderWidgetHostView::SetNeedsBeginFrames(
   begin_frame_timer_->SetActive(needs_begin_frames);
 
   if (software_output_device_) {
-    software_output_device_->SetActive(needs_begin_frames && painting_, false);
+    software_output_device_->SetActive(painting_, false);
   }
 }
 
@@ -937,8 +936,6 @@ void OffScreenRenderWidgetHostView::SetWantsAnimateOnlyBeginFrames() {
 
 void OffScreenRenderWidgetHostView::OnPaint(const gfx::Rect& damage_rect,
                                             const SkBitmap& bitmap) {
-  TRACE_EVENT0("electron", "OffScreenRenderWidgetHostView::OnPaint");
-
   HoldResize();
 
   if (parent_callback_) {
@@ -1023,10 +1020,6 @@ void OffScreenRenderWidgetHostView::SynchronizeVisualProperties() {
   }
 
   ResizeRootLayer(false);
-  if (render_widget_host_)
-    render_widget_host_->SynchronizeVisualProperties();
-  GetDelegatedFrameHost()->EmbedSurface(
-      local_surface_id_, size_, cc::DeadlinePolicy::UseDefaultDeadline());
 }
 
 void OffScreenRenderWidgetHostView::SendMouseEvent(
@@ -1192,6 +1185,13 @@ ui::Layer* OffScreenRenderWidgetHostView::GetRootLayer() const {
   return root_layer_.get();
 }
 
+#if !defined(OS_MACOSX)
+const viz::LocalSurfaceIdAllocation&
+OffScreenRenderWidgetHostView::GetLocalSurfaceIdAllocation() const {
+  return local_surface_id_allocation_;
+}
+#endif  // defined(OS_MACOSX)
+
 content::DelegatedFrameHost*
 OffScreenRenderWidgetHostView::GetDelegatedFrameHost() const {
   return delegated_frame_host_.get();
@@ -1204,11 +1204,6 @@ void OffScreenRenderWidgetHostView::SetupFrameRate(bool force) {
 
   frame_rate_threshold_us_ = 1000000 / frame_rate_;
 
-  if (GetCompositor()) {
-    GetCompositor()->SetAuthoritativeVSyncInterval(
-        base::TimeDelta::FromMicroseconds(frame_rate_threshold_us_));
-  }
-
   if (copy_frame_generator_.get()) {
     copy_frame_generator_->set_frame_rate_threshold_us(
         frame_rate_threshold_us_);
@@ -1257,28 +1252,32 @@ void OffScreenRenderWidgetHostView::ResizeRootLayer(bool force) {
       size == GetRootLayer()->bounds().size())
     return;
 
-  const gfx::Size& size_in_pixels =
-      gfx::ConvertSizeToPixel(current_device_scale_factor_, size);
-
-  local_surface_id_ = local_surface_id_allocator_.GenerateId();
-
   GetRootLayer()->SetBounds(gfx::Rect(size));
-  GetCompositor()->SetScaleAndSize(current_device_scale_factor_, size_in_pixels,
-                                   local_surface_id_);
 
 #if defined(OS_MACOSX)
   bool resized = UpdateNSViewAndDisplay();
 #else
+  const gfx::Size& size_in_pixels =
+      gfx::ConvertSizeToPixel(current_device_scale_factor_, size);
+
+  local_surface_id_allocator_.GenerateId();
+  local_surface_id_allocation_ =
+      local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
+
+  GetCompositor()->SetScaleAndSize(current_device_scale_factor_, size_in_pixels,
+                                   local_surface_id_allocation_);
   bool resized = true;
   GetDelegatedFrameHost()->EmbedSurface(
-      local_surface_id_, size, cc::DeadlinePolicy::UseDefaultDeadline());
+      local_surface_id_allocation_.local_surface_id(), size,
+      cc::DeadlinePolicy::UseDefaultDeadline());
 #endif
 
   // Note that |render_widget_host_| will retrieve resize parameters from the
   // DelegatedFrameHost, so it must have SynchronizeVisualProperties called
   // after.
-  if (resized && render_widget_host_)
+  if (resized && render_widget_host_) {
     render_widget_host_->SynchronizeVisualProperties();
+  }
 }
 
 viz::FrameSinkId OffScreenRenderWidgetHostView::AllocateFrameSinkId(

atom/browser/osr/osr_render_widget_host_view.h

@@ -66,13 +66,12 @@ class AtomBeginFrameTimer;
 
 #if defined(OS_MACOSX)
 class MacHelper;
+#else
+class AtomDelegatedFrameHostClient;
 #endif
 
 class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
                                       public ui::CompositorDelegate,
-#if !defined(OS_MACOSX)
-                                      public content::DelegatedFrameHostClient,
-#endif
                                       public OffscreenViewProxyObserver {
  public:
   OffScreenRenderWidgetHostView(bool transparent,
@@ -118,7 +117,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void SetActive(bool active) override;
   void ShowDefinitionForSelection() override;
   void SpeakSelection() override;
-  bool ShouldContinueToPauseForFrame() override;
   bool UpdateNSViewAndDisplay();
 #endif  // defined(OS_MACOSX)
 
@@ -144,8 +142,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void Destroy(void) override;
   void SetTooltipText(const base::string16&) override;
   content::CursorManager* GetCursorManager() override;
-  void SelectionBoundsChanged(
-      const ViewHostMsg_SelectionBounds_Params&) override;
   void CopyFromSurface(
       const gfx::Rect& src_rect,
       const gfx::Size& output_size,
@@ -170,18 +166,8 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
       content::RenderWidgetHost*,
       content::WebContentsView*) override;
 
-#if !defined(OS_MACOSX)
-  // content::DelegatedFrameHostClient:
-  int DelegatedFrameHostGetGpuMemoryBufferClientId(void) const;
-  ui::Layer* DelegatedFrameHostGetLayer(void) const override;
-  bool DelegatedFrameHostIsVisible(void) const override;
-  SkColor DelegatedFrameHostGetGutterColor() const override;
-  void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;
-  void OnBeginFrame(base::TimeTicks frame_time) override;
-  void OnFrameTokenChanged(uint32_t frame_token) override;
-#endif  // !defined(OS_MACOSX)
-
-  const viz::LocalSurfaceId& GetLocalSurfaceId() const override;
+  const viz::LocalSurfaceIdAllocation& GetLocalSurfaceIdAllocation()
+      const override;
   const viz::FrameSinkId& GetFrameSinkId() const override;
 
   void DidNavigate() override;
@@ -220,16 +206,13 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void RemoveViewProxy(OffscreenViewProxy* proxy);
   void ProxyViewDestroyed(OffscreenViewProxy* proxy) override;
 
-  void RegisterGuestViewFrameSwappedCallback(
-      content::RenderWidgetHostViewGuest* guest_host_view);
-  void OnGuestViewFrameSwapped(
-      content::RenderWidgetHostViewGuest* guest_host_view);
-
   void OnPaint(const gfx::Rect& damage_rect, const SkBitmap& bitmap);
   void OnPopupPaint(const gfx::Rect& damage_rect, const SkBitmap& bitmap);
   void OnProxyViewPaint(const gfx::Rect& damage_rect) override;
 
-  bool IsPopupWidget() const { return popup_type_ != blink::kWebPopupTypeNone; }
+  bool IsPopupWidget() const {
+    return widget_type_ == content::WidgetType::kPopup;
+  }
 
   void HoldResize();
   void ReleaseResize();
@@ -322,7 +305,7 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
 
   bool paint_callback_running_ = false;
 
-  viz::LocalSurfaceId local_surface_id_;
+  viz::LocalSurfaceIdAllocation local_surface_id_allocation_;
   viz::ParentLocalSurfaceIdAllocator local_surface_id_allocator_;
 
   std::unique_ptr<ui::Layer> root_layer_;
@@ -349,6 +332,8 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
 
   // Selected text on the renderer.
   std::string selected_text_;
+#else
+  std::unique_ptr<AtomDelegatedFrameHostClient> delegated_frame_host_client_;
 #endif
 
   content::MouseWheelPhaseHandler mouse_wheel_phase_handler_;

atom/browser/osr/osr_render_widget_host_view_mac.mm

@@ -11,13 +11,15 @@
 #include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 #include "ui/display/screen.h"
 
+#include "components/viz/common/features.h"
+
 namespace atom {
 
 class MacHelper : public content::BrowserCompositorMacClient,
                   public ui::AcceleratedWidgetMacNSView {
  public:
   explicit MacHelper(OffScreenRenderWidgetHostView* view) : view_(view) {
-    [view_->GetNativeView() setWantsLayer:YES];
+    [view_->GetNativeView().GetNativeNSView() setWantsLayer:YES];
   }
 
   virtual ~MacHelper() {}
@@ -44,25 +46,14 @@ class MacHelper : public content::BrowserCompositorMacClient,
 
   void DestroyCompositorForShutdown() override {}
 
-  bool SynchronizeVisualProperties(
-      const base::Optional<viz::LocalSurfaceId>&
-          child_allocated_local_surface_id) override {
-    auto* browser_compositor = view_->browser_compositor();
-    if (child_allocated_local_surface_id) {
-      browser_compositor->UpdateRendererLocalSurfaceIdFromChild(
-          *child_allocated_local_surface_id);
-    } else {
-      browser_compositor->AllocateNewRendererLocalSurfaceId();
-    }
-
-    if (auto* host = browser_compositor->GetDelegatedFrameHost()) {
-      host->EmbedSurface(browser_compositor->GetRendererLocalSurfaceId(),
-                         browser_compositor->GetRendererSize(),
-                         cc::DeadlinePolicy::UseDefaultDeadline());
-    }
+  bool OnBrowserCompositorSurfaceIdChanged() override {
     return view_->render_widget_host()->SynchronizeVisualProperties();
   }
 
+  std::vector<viz::SurfaceId> CollectSurfaceIdsForEviction() override {
+    return view_->render_widget_host()->CollectSurfaceIdsForEviction();
+  }
+
  private:
   OffScreenRenderWidgetHostView* view_;
 
@@ -76,20 +67,20 @@ void OffScreenRenderWidgetHostView::ShowDefinitionForSelection() {}
 void OffScreenRenderWidgetHostView::SpeakSelection() {}
 
 bool OffScreenRenderWidgetHostView::UpdateNSViewAndDisplay() {
-  return browser_compositor_->UpdateNSViewAndDisplay(
+  return browser_compositor_->UpdateSurfaceFromNSView(
       GetRootLayer()->bounds().size(), GetDisplay());
 }
 
-bool OffScreenRenderWidgetHostView::ShouldContinueToPauseForFrame() {
-  return browser_compositor_->ShouldContinueToPauseForFrame();
-}
-
 void OffScreenRenderWidgetHostView::CreatePlatformWidget(
     bool is_guest_view_hack) {
   mac_helper_ = new MacHelper(this);
   browser_compositor_.reset(new content::BrowserCompositorMac(
       mac_helper_, mac_helper_, render_widget_host_->is_hidden(), GetDisplay(),
       AllocateFrameSinkId(is_guest_view_hack)));
+
+  if (!base::FeatureList::IsEnabled(features::kVizDisplayCompositor)) {
+    SetNeedsBeginFrames(true);
+  }
 }
 
 void OffScreenRenderWidgetHostView::DestroyPlatformWidget() {
@@ -132,14 +123,15 @@ display::Display OffScreenRenderWidgetHostView::GetDisplay() {
 void OffScreenRenderWidgetHostView::OnDidUpdateVisualPropertiesComplete(
     const cc::RenderFrameMetadata& metadata) {
   DCHECK_EQ(current_device_scale_factor_, metadata.device_scale_factor);
-  browser_compositor_->SynchronizeVisualProperties(
+  browser_compositor_->UpdateSurfaceFromChild(
       metadata.device_scale_factor, metadata.viewport_size_in_pixels,
-      metadata.local_surface_id.value_or(viz::LocalSurfaceId()));
+      metadata.local_surface_id_allocation.value_or(
+          viz::LocalSurfaceIdAllocation()));
 }
 
-const viz::LocalSurfaceId& OffScreenRenderWidgetHostView::GetLocalSurfaceId()
-    const {
-  return browser_compositor_->GetRendererLocalSurfaceId();
+const viz::LocalSurfaceIdAllocation&
+OffScreenRenderWidgetHostView::GetLocalSurfaceIdAllocation() const {
+  return browser_compositor_->GetRendererLocalSurfaceIdAllocation();
 }
 
 ui::Compositor* OffScreenRenderWidgetHostView::GetCompositor() const {

atom/browser/osr/osr_web_contents_view.cc

@@ -128,7 +128,7 @@ OffScreenWebContentsView::CreateViewForWidget(
 }
 
 content::RenderWidgetHostViewBase*
-OffScreenWebContentsView::CreateViewForPopupWidget(
+OffScreenWebContentsView::CreateViewForChildWidget(
     content::RenderWidgetHost* render_widget_host) {
   content::WebContentsImpl* web_contents_impl =
       static_cast<content::WebContentsImpl*>(web_contents_);

atom/browser/osr/osr_web_contents_view.h

@@ -57,7 +57,7 @@ class OffScreenWebContentsView : public content::WebContentsView,
   content::RenderWidgetHostViewBase* CreateViewForWidget(
       content::RenderWidgetHost* render_widget_host,
       bool is_guest_view_hack) override;
-  content::RenderWidgetHostViewBase* CreateViewForPopupWidget(
+  content::RenderWidgetHostViewBase* CreateViewForChildWidget(
       content::RenderWidgetHost* render_widget_host) override;
   void SetPageTitle(const base::string16& title) override;
   void RenderViewCreated(content::RenderViewHost* host) override;

buildflags/buildflags.gni

@@ -8,7 +8,7 @@ declare_args() {
   # Allow running Electron as a node binary.
   enable_run_as_node = true
 
-  enable_osr = false
+  enable_osr = true
 
   enable_view_api = false