aw: Add HardwareRendererViz

This CL adds HardwareRendererViz as part of implementation of
'Viz for WebView' path. HardwareRendererViz responsible for submitting
root CompositorFrames.

Bug: 805739
Change-Id: If5b57c39e3d625286248598f23aaa29a9ab55025
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863136
Commit-Queue: Vasiliy Telezhnikov <vasilyt@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#708169}

android_webview/browser/gfx/BUILD.gn

@@ -34,6 +34,8 @@ source_set("gfx") {
     "hardware_renderer.h",
     "hardware_renderer_single_thread.cc",
     "hardware_renderer_single_thread.h",
+    "hardware_renderer_viz.cc",
+    "hardware_renderer_viz.h",
     "java_browser_view_renderer_helper.cc",
     "java_browser_view_renderer_helper.h",
     "output_surface_provider_webview.cc",

android_webview/browser/gfx/browser_view_renderer.cc

@@ -137,7 +137,11 @@ void BrowserViewRenderer::SetCurrentCompositorFrameConsumer(
   }
   current_compositor_frame_consumer_ = compositor_frame_consumer;
   if (current_compositor_frame_consumer_) {
-    current_compositor_frame_consumer_->SetCompositorFrameProducer(this);
+    RootFrameSinkGetter root_sink_getter;
+    if (root_frame_sink_proxy_)
+      root_sink_getter = root_frame_sink_proxy_->GetRootFrameSinkCallback();
+    current_compositor_frame_consumer_->SetCompositorFrameProducer(
+        this, std::move(root_sink_getter));
     OnParentDrawDataUpdated(current_compositor_frame_consumer_);
   }
 }
@@ -302,7 +306,7 @@ bool BrowserViewRenderer::OnDrawHardware() {
   }
   std::unique_ptr<ChildFrame> child_frame = std::make_unique<ChildFrame>(
       std::move(future), frame_sink_id_, viewport_size_for_tile_priority,
-      external_draw_constraints_.transform, offscreen_pre_raster_,
+      external_draw_constraints_.transform, offscreen_pre_raster_, dip_scale_,
       std::move(requests));
 
   ReturnUnusedResource(

android_webview/browser/gfx/child_frame.cc

@@ -18,12 +18,14 @@ ChildFrame::ChildFrame(
     const gfx::Size& viewport_size_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority,
     bool offscreen_pre_raster,
+    float device_scale_factor,
     CopyOutputRequestQueue copy_requests)
     : frame_future(std::move(frame_future)),
       frame_sink_id(frame_sink_id),
       viewport_size_for_tile_priority(viewport_size_for_tile_priority),
       transform_for_tile_priority(transform_for_tile_priority),
       offscreen_pre_raster(offscreen_pre_raster),
+      device_scale_factor(device_scale_factor),
       copy_requests(std::move(copy_requests)) {}
 
 ChildFrame::~ChildFrame() {
@@ -39,8 +41,14 @@ void ChildFrame::WaitOnFutureIfNeeded() {
   if (frame_ptr) {
     layer_tree_frame_sink_id = frame_ptr->layer_tree_frame_sink_id;
     frame = std::move(frame_ptr->frame);
+    local_surface_id = frame_future->local_surface_id();
   }
   frame_future = nullptr;
 }
 
+viz::SurfaceId ChildFrame::GetSurfaceId() const {
+  DCHECK(!frame_future);
+  return viz::SurfaceId(frame_sink_id, local_surface_id);
+}
+
 }  // namespace android_webview

android_webview/browser/gfx/child_frame.h

@@ -11,6 +11,7 @@
 #include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "components/viz/common/surfaces/frame_sink_id.h"
+#include "components/viz/common/surfaces/surface_id.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/transform.h"
@@ -33,11 +34,13 @@ class ChildFrame {
       const gfx::Size& viewport_size_for_tile_priority,
       const gfx::Transform& transform_for_tile_priority,
       bool offscreen_pre_raster,
+      float device_scale_factor,
       CopyOutputRequestQueue copy_requests);
   ~ChildFrame();
 
   // Helper to move frame from |frame_future| to |frame|.
   void WaitOnFutureIfNeeded();
+  viz::SurfaceId GetSurfaceId() const;
 
   // The frame is either in |frame_future| or |frame|. It's illegal if both
   // are non-null.
@@ -46,9 +49,12 @@ class ChildFrame {
   std::unique_ptr<viz::CompositorFrame> frame;
   // The id of the compositor this |frame| comes from.
   const viz::FrameSinkId frame_sink_id;
+  // local surface id of the frame, used with viz for webview
+  viz::LocalSurfaceId local_surface_id;
   const gfx::Size viewport_size_for_tile_priority;
   const gfx::Transform transform_for_tile_priority;
   const bool offscreen_pre_raster;
+  const float device_scale_factor;
   CopyOutputRequestQueue copy_requests;
 
  private:

android_webview/browser/gfx/compositor_frame_consumer.h

@@ -7,6 +7,7 @@
 
 #include "android_webview/browser/gfx/child_frame.h"
 #include "android_webview/browser/gfx/parent_compositor_draw_constraints.h"
+#include "android_webview/browser/gfx/root_frame_sink.h"
 #include "components/viz/common/frame_timing_details_map.h"
 #include "ui/gfx/geometry/vector2d.h"
 
@@ -29,7 +30,8 @@ class CompositorFrameConsumer {
   // In order to register a consumer with a new producer, the current producer
   // must unregister the consumer, and call SetCompositorProducer(nullptr).
   virtual void SetCompositorFrameProducer(
-      CompositorFrameProducer* compositor_frame_producer) = 0;
+      CompositorFrameProducer* compositor_frame_producer,
+      RootFrameSinkGetter root_frame_sink_getter) = 0;
   virtual void SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) = 0;
   // Returns uncommitted frame to be returned, if any.
   virtual std::unique_ptr<ChildFrame> SetFrameOnUI(

android_webview/browser/gfx/hardware_renderer_viz.h

+// 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.
+
+#ifndef ANDROID_WEBVIEW_BROWSER_GFX_HARDWARE_RENDERER_VIZ_H_
+#define ANDROID_WEBVIEW_BROWSER_GFX_HARDWARE_RENDERER_VIZ_H_
+
+#include <memory>
+
+#include "android_webview/browser/gfx/hardware_renderer.h"
+#include "android_webview/browser/gfx/output_surface_provider_webview.h"
+#include "android_webview/browser/gfx/root_frame_sink.h"
+#include "base/macros.h"
+#include "base/threading/thread_checker.h"
+#include "components/viz/common/surfaces/frame_sink_id.h"
+
+namespace android_webview {
+
+class HardwareRendererViz : public HardwareRenderer {
+ public:
+  HardwareRendererViz(RenderThreadManager* state,
+                      RootFrameSinkGetter root_frame_sink_getter);
+  ~HardwareRendererViz() override;
+
+  // HardwareRenderer overrides.
+  void DrawAndSwap(HardwareRendererDrawParams* params) override;
+
+ private:
+  class OnViz;
+
+  void InitializeOnViz(RootFrameSinkGetter root_frame_sink_getter);
+  void DestroyOnViz();
+  bool IsUsingVulkan() const;
+
+  // Information about last delegated frame.
+  gfx::Size surface_size_;
+  float device_scale_factor_ = 0;
+
+  viz::SurfaceId surface_id_;
+
+  // Used to create viz::OutputSurface and gl::GLSurface
+  OutputSurfaceProviderWebview output_surface_provider_;
+
+  // These are accessed on the viz thread.
+  std::unique_ptr<OnViz> on_viz_;
+
+  THREAD_CHECKER(render_thread_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(HardwareRendererViz);
+};
+
+}  // namespace android_webview
+
+#endif  // ANDROID_WEBVIEW_BROWSER_GFX_HARDWARE_RENDERER_VIZ_H_

android_webview/browser/gfx/render_thread_manager.cc

@@ -8,8 +8,11 @@
 
 #include "android_webview/browser/gfx/compositor_frame_producer.h"
 #include "android_webview/browser/gfx/gpu_service_web_view.h"
+#include "android_webview/browser/gfx/hardware_renderer_single_thread.h"
+#include "android_webview/browser/gfx/hardware_renderer_viz.h"
 #include "android_webview/browser/gfx/scoped_app_gl_state_restore.h"
 #include "android_webview/browser/gfx/task_queue_web_view.h"
+#include "android_webview/common/aw_features.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ -189,7 +192,18 @@ void RenderThreadManager::DrawOnRT(bool save_restore,
   ScopedAllowGL allow_gl;
   if (!hardware_renderer_ && !IsInsideHardwareRelease() &&
       HasFrameForHardwareRendererOnRT()) {
-    hardware_renderer_.reset(new HardwareRendererSingleThread(this));
+    if (base::FeatureList::IsEnabled(features::kVizForWebView)) {
+      RootFrameSinkGetter getter;
+      {
+        base::AutoLock lock(lock_);
+        getter = root_frame_sink_getter_;
+      }
+      DCHECK(getter);
+      hardware_renderer_.reset(
+          new HardwareRendererViz(this, std::move(getter)));
+    } else {
+      hardware_renderer_.reset(new HardwareRendererSingleThread(this));
+    }
     hardware_renderer_->CommitFrame();
   }
 
@@ -217,10 +231,14 @@ void RenderThreadManager::RemoveFromCompositorFrameProducerOnUI() {
 }
 
 void RenderThreadManager::SetCompositorFrameProducer(
-    CompositorFrameProducer* compositor_frame_producer) {
+    CompositorFrameProducer* compositor_frame_producer,
+    RootFrameSinkGetter root_frame_sink_getter) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   CheckUiCallsAllowed();
   producer_weak_ptr_ = compositor_frame_producer->GetWeakPtr();
+
+  base::AutoLock lock(lock_);
+  root_frame_sink_getter_ = std::move(root_frame_sink_getter);
 }
 
 bool RenderThreadManager::HasFrameForHardwareRendererOnRT() const {

android_webview/browser/gfx/render_thread_manager.h

@@ -8,8 +8,9 @@
 #include <map>
 
 #include "android_webview/browser/gfx/compositor_frame_consumer.h"
-#include "android_webview/browser/gfx/hardware_renderer_single_thread.h"
+#include "android_webview/browser/gfx/hardware_renderer.h"
 #include "android_webview/browser/gfx/parent_compositor_draw_constraints.h"
+#include "android_webview/browser/gfx/root_frame_sink.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -22,7 +23,6 @@ namespace android_webview {
 
 class ChildFrame;
 class CompositorFrameProducer;
-class HardwareRenderer;
 
 // This class is used to pass data between UI thread and RenderThread.
 class RenderThreadManager : public CompositorFrameConsumer {
@@ -33,7 +33,8 @@ class RenderThreadManager : public CompositorFrameConsumer {
 
   // CompositorFrameConsumer methods.
   void SetCompositorFrameProducer(
-      CompositorFrameProducer* compositor_frame_producer) override;
+      CompositorFrameProducer* compositor_frame_producer,
+      RootFrameSinkGetter root_frame_sink_getter) override;
   void SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) override;
   std::unique_ptr<ChildFrame> SetFrameOnUI(
       std::unique_ptr<ChildFrame> frame) override;
@@ -110,6 +111,7 @@ class RenderThreadManager : public CompositorFrameConsumer {
 
   // Accessed by both UI and RT thread.
   mutable base::Lock lock_;
+  RootFrameSinkGetter root_frame_sink_getter_;
   gfx::Vector2d scroll_offset_;
   ChildFrameQueue child_frames_;
   bool mark_hardware_release_;

android_webview/browser/gfx/root_frame_sink.h

@@ -70,7 +70,8 @@ class RootFrameSink : public base::RefCounted<RootFrameSink>,
   DISALLOW_COPY_AND_ASSIGN(RootFrameSink);
 };
 
-using RootFrameSinkGetter = base::OnceCallback<scoped_refptr<RootFrameSink>()>;
+using RootFrameSinkGetter =
+    base::RepeatingCallback<scoped_refptr<RootFrameSink>()>;
 
 }  // namespace android_webview
 

android_webview/browser/gfx/root_frame_sink_proxy.cc

@@ -116,8 +116,8 @@ void RootFrameSinkProxy::BeginFrameOnViz(const viz::BeginFrameArgs& args,
 }
 
 RootFrameSinkGetter RootFrameSinkProxy::GetRootFrameSinkCallback() {
-  return base::BindOnce(&RootFrameSinkProxy::GetRootFrameSinkHelper,
-                        weak_ptr_factory_on_viz_.GetWeakPtr());
+  return base::BindRepeating(&RootFrameSinkProxy::GetRootFrameSinkHelper,
+                             weak_ptr_factory_on_viz_.GetWeakPtr());
 }
 
 }  // namespace android_webview

content/browser/android/synchronous_compositor_host.cc

@@ -157,7 +157,8 @@ SynchronousCompositorHost::DemandDrawHwAsync(
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   invalidate_needs_draw_ = false;
-  scoped_refptr<FrameFuture> frame_future = new FrameFuture();
+  scoped_refptr<FrameFuture> frame_future =
+      new FrameFuture(rwhva_->GetLocalSurfaceIdAllocation().local_surface_id());
   if (compute_scroll_needs_synchronous_draw_ || !allow_async_draw_) {
     allow_async_draw_ = allow_async_draw_ || IsReadyForSynchronousCall();
     compute_scroll_needs_synchronous_draw_ = false;

content/public/browser/android/synchronous_compositor.cc

@@ -19,9 +19,11 @@ SynchronousCompositor::Frame::Frame(Frame&& rhs)
     : layer_tree_frame_sink_id(rhs.layer_tree_frame_sink_id),
       frame(std::move(rhs.frame)) {}
 
-SynchronousCompositor::FrameFuture::FrameFuture()
+SynchronousCompositor::FrameFuture::FrameFuture(
+    viz::LocalSurfaceId local_surface_id)
     : waitable_event_(base::WaitableEvent::ResetPolicy::MANUAL,
-                      base::WaitableEvent::InitialState::NOT_SIGNALED) {}
+                      base::WaitableEvent::InitialState::NOT_SIGNALED),
+      local_surface_id_(local_surface_id) {}
 
 SynchronousCompositor::FrameFuture::~FrameFuture() {}
 

content/public/browser/android/synchronous_compositor.h

@@ -14,6 +14,7 @@
 #include "base/time/time.h"
 #include "components/viz/common/frame_timing_details_map.h"
 #include "components/viz/common/resources/returned_resource.h"
+#include "components/viz/common/surfaces/local_surface_id.h"
 #include "content/common/content_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ -61,9 +62,10 @@ class CONTENT_EXPORT SynchronousCompositor {
 
   class FrameFuture : public base::RefCountedThreadSafe<FrameFuture> {
    public:
-    FrameFuture();
+    explicit FrameFuture(viz::LocalSurfaceId local_surface_id);
     void SetFrame(std::unique_ptr<Frame> frame);
     std::unique_ptr<Frame> GetFrame();
+    const viz::LocalSurfaceId& local_surface_id() { return local_surface_id_; }
 
    private:
     friend class base::RefCountedThreadSafe<FrameFuture>;
@@ -71,6 +73,7 @@ class CONTENT_EXPORT SynchronousCompositor {
 
     base::WaitableEvent waitable_event_;
     std::unique_ptr<Frame> frame_;
+    viz::LocalSurfaceId local_surface_id_;
 #if DCHECK_IS_ON()
     bool waited_ = false;
 #endif

content/public/test/test_synchronous_compositor_android.cc

@@ -31,7 +31,8 @@ TestSynchronousCompositor::DemandDrawHwAsync(
     const gfx::Size& viewport_size,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
-  auto future = base::MakeRefCounted<FrameFuture>();
+  auto future = base::MakeRefCounted<FrameFuture>(
+      viz::LocalSurfaceId(1, base::UnguessableToken::Create()));
   future->SetFrame(std::move(hardware_frame_));
   return future;
 }