aw: support CopyOutputRequests with SkiaRenderer

SkiaRenderer used PostDelayTask on GPU thread to check for
CopyOutputRequests are complete. It's incompatible with WebView.

This CL adds SkiaOutputSurfaceDependency::ScheduleDelayedTaskOnGPU to
support this behaviour. For Chrome it still posts PostDelayTask as
before. For WebView it adds tasks to TaskQueueWebView.

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

android_webview/browser/gfx/skia_output_surface_dependency_webview.cc

@@ -148,4 +148,9 @@ SkiaOutputSurfaceDependencyWebView::GetGpuBlockedTimeSinceLastSwap() {
   return base::TimeDelta();
 }
 
+void SkiaOutputSurfaceDependencyWebView::ScheduleDelayedGPUTaskFromGPUThread(
+    base::OnceClosure task) {
+  task_queue_->ScheduleIdleTask(std::move(task));
+}
+
 }  // namespace android_webview

android_webview/browser/gfx/skia_output_surface_dependency_webview.h

@@ -40,6 +40,7 @@ class SkiaOutputSurfaceDependencyWebView
   gpu::MailboxManager* GetMailboxManager() override;
   gpu::ImageFactory* GetGpuImageFactory() override;
   void ScheduleGrContextCleanup() override;
+  void ScheduleDelayedGPUTaskFromGPUThread(base::OnceClosure task) override;
   void PostTaskToClientThread(base::OnceClosure closure) override;
   bool IsOffscreen() override;
   gpu::SurfaceHandle GetSurfaceHandle() override;

android_webview/browser/gfx/task_queue_web_view.cc

@@ -183,10 +183,14 @@ class TaskQueueViz : public TaskQueueWebView {
   void EmplaceTask(base::OnceClosure task);
 
   scoped_refptr<base::SingleThreadTaskRunner> viz_task_runner_;
+  THREAD_CHECKER(render_thread_checker_);
 
   // Only accessed on viz thread.
   bool allow_schedule_task_ = false;
 
+  // Only accessed on render thread.
+  bool inside_schedule_on_viz_and_block_ = false;
+
   base::Lock lock_;
   base::ConditionVariable condvar_{&lock_};
   bool done_ GUARDED_BY(lock_) = true;
@@ -195,7 +199,10 @@ class TaskQueueViz : public TaskQueueWebView {
   DISALLOW_COPY_AND_ASSIGN(TaskQueueViz);
 };
 
-TaskQueueViz::TaskQueueViz() = default;
+TaskQueueViz::TaskQueueViz() {
+  DETACH_FROM_THREAD(render_thread_checker_);
+}
+
 TaskQueueViz::~TaskQueueViz() = default;
 
 void TaskQueueViz::ScheduleTask(base::OnceClosure task, bool out_of_order) {
@@ -231,7 +238,9 @@ void TaskQueueViz::EmplaceTask(base::OnceClosure task) {
 }
 
 void TaskQueueViz::ScheduleIdleTask(base::OnceClosure task) {
-  NOTREACHED();
+  DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
+  DCHECK(inside_schedule_on_viz_and_block_);
+  EmplaceTask(std::move(task));
 }
 
 void TaskQueueViz::ScheduleClientTask(base::OnceClosure task) {
@@ -251,6 +260,7 @@ void TaskQueueViz::InitializeVizThread(
 
 void TaskQueueViz::ScheduleOnVizAndBlock(VizTask viz_task) {
   TRACE_EVENT0("android_webview", "ScheduleOnVizAndBlock");
+  DCHECK_CALLED_ON_VALID_THREAD(render_thread_checker_);
 
   // Expected behavior is |viz_task| on the viz thread. From |viz_task| until
   // the done closure is called (which may not be in the viz_task), viz thread
@@ -272,6 +282,9 @@ void TaskQueueViz::ScheduleOnVizAndBlock(VizTask viz_task) {
                                 std::move(viz_task)));
 
   {
+    DCHECK(!inside_schedule_on_viz_and_block_);
+    base::AutoReset<bool> inside_bf(&inside_schedule_on_viz_and_block_, true);
+
     base::AutoLock lock(lock_);
     while (!done_ || !tasks_.empty()) {
       if (tasks_.empty())

android_webview/lib/aw_main_delegate.cc

@@ -184,6 +184,7 @@ bool AwMainDelegate::BasicStartupComplete(int* exit_code) {
     // all flags in trial config.
     if (features.IsEnabled(::features::kVizForWebView)) {
       features.EnableIfNotSet(::features::kEnableSharedImageForWebview);
+      features.EnableIfNotSet(::features::kUseSkiaForGLReadback);
       features.EnableIfNotSet(::features::kUseSkiaRenderer);
     } else {
       // Viz for WebView is required to support embedding CompositorFrameSinks

components/viz/service/display_embedder/skia_output_surface_dependency.h

@@ -94,6 +94,10 @@ class VIZ_SERVICE_EXPORT SkiaOutputSurfaceDependency {
   virtual void PostTaskToClientThread(base::OnceClosure closure) = 0;
   virtual void ScheduleGrContextCleanup() = 0;
 
+  // This function schedules delayed task to be run on GPUThread. It can be
+  // called only from GPU Thread.
+  virtual void ScheduleDelayedGPUTaskFromGPUThread(base::OnceClosure task) = 0;
+
 #if defined(OS_WIN)
   virtual void DidCreateAcceleratedSurfaceChildWindow(
       gpu::SurfaceHandle parent_window,

components/viz/service/display_embedder/skia_output_surface_dependency_impl.cc

@@ -131,6 +131,16 @@ void SkiaOutputSurfaceDependencyImpl::ScheduleGrContextCleanup() {
   gpu_service_impl_->gpu_channel_manager()->ScheduleGrContextCleanup();
 }
 
+void SkiaOutputSurfaceDependencyImpl::ScheduleDelayedGPUTaskFromGPUThread(
+    base::OnceClosure task) {
+  DCHECK(gpu_service_impl_->main_runner()->BelongsToCurrentThread());
+
+  constexpr base::TimeDelta kDelayForDelayedWork =
+      base::TimeDelta::FromMilliseconds(2);
+  gpu_service_impl_->main_runner()->PostDelayedTask(FROM_HERE, std::move(task),
+                                                    kDelayForDelayedWork);
+}
+
 #if defined(OS_WIN)
 void SkiaOutputSurfaceDependencyImpl::DidCreateAcceleratedSurfaceChildWindow(
     gpu::SurfaceHandle parent_window,

components/viz/service/display_embedder/skia_output_surface_dependency_impl.h

@@ -46,6 +46,7 @@ class VIZ_SERVICE_EXPORT SkiaOutputSurfaceDependencyImpl
   base::ScopedClosureRunner CacheGLSurface(gl::GLSurface* surface) override;
   void PostTaskToClientThread(base::OnceClosure closure) override;
   void ScheduleGrContextCleanup() override;
+  void ScheduleDelayedGPUTaskFromGPUThread(base::OnceClosure task) override;
 
 #if defined(OS_WIN)
   void DidCreateAcceleratedSurfaceChildWindow(

components/viz/service/display_embedder/skia_output_surface_impl_on_gpu.cc

@@ -1699,11 +1699,9 @@ void SkiaOutputSurfaceImplOnGpu::MarkContextLost() {
 
 void SkiaOutputSurfaceImplOnGpu::ScheduleCheckReadbackCompletion() {
   if (num_readbacks_pending_ > 0 && !readback_poll_pending_) {
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
+    dependency_->ScheduleDelayedGPUTaskFromGPUThread(
         base::BindOnce(&SkiaOutputSurfaceImplOnGpu::CheckReadbackCompletion,
-                       weak_ptr_factory_.GetWeakPtr()),
-        kReadbackPollingInterval);
+                       weak_ptr_factory_.GetWeakPtr()));
     readback_poll_pending_ = true;
   }
 }