aw: ReturnedResourceAvailable

Resources are only explicitly returned from OnDraw. This means it's
possible for resources to be stuck in RenderThreadManager
returned_resources_map_ indefinitely, if OnDraw stops.

Post a task with roughly 2 frames of delay to return these resources to
ensure that they don't get stuck indefinitely.

Bug: 881957
Change-Id: I2a6331b9251b4057125761eb9fb0aaf29c881eeb
Reviewed-on: https://chromium-review.googlesource.com/1214700Reviewed-by: Tobias Sargeant <tobiasjs@chromium.org>
Commit-Queue: Bo <boliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#590501}

android_webview/browser/browser_view_renderer.cc

@@ -257,6 +257,12 @@ gfx::Rect BrowserViewRenderer::ComputeViewportRectForTilePriority() {
   return viewport_rect_for_tile_priority;
 }
 
+void BrowserViewRenderer::ReturnedResourceAvailable(
+    CompositorFrameConsumer* compositor_frame_consumer) {
+  DCHECK(compositor_frame_consumers_.count(compositor_frame_consumer));
+  ReturnResourceFromParent(compositor_frame_consumer);
+}
+
 void BrowserViewRenderer::OnParentDrawConstraintsUpdated(
     CompositorFrameConsumer* compositor_frame_consumer) {
   DCHECK(compositor_frame_consumer);

android_webview/browser/browser_view_renderer.h

@@ -141,6 +141,8 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient,
   ui::TouchHandleDrawable* CreateDrawable() override;
 
   // CompositorFrameProducer overrides
+  void ReturnedResourceAvailable(
+      CompositorFrameConsumer* compositor_frame_consumer) override;
   void OnParentDrawConstraintsUpdated(
       CompositorFrameConsumer* compositor_frame_consumer) override;
   void RemoveCompositorFrameConsumer(

android_webview/browser/compositor_frame_producer.h

@@ -11,6 +11,8 @@ class CompositorFrameConsumer;
 
 class CompositorFrameProducer {
  public:
+  virtual void ReturnedResourceAvailable(
+      CompositorFrameConsumer* compositor_frame_consumer) = 0;
   virtual void OnParentDrawConstraintsUpdated(
       CompositorFrameConsumer* compositor_frame_consumer) = 0;
   virtual void RemoveCompositorFrameConsumer(

android_webview/browser/render_thread_manager.cc

@@ -88,6 +88,9 @@ namespace {
 
 base::LazyInstance<internal::RequestInvokeGLTracker>::DestructorAtExit
     g_request_invoke_gl_tracker = LAZY_INSTANCE_INITIALIZER;
+
+constexpr base::TimeDelta kSlightlyMoreThanOneFrame =
+    base::TimeDelta::FromMilliseconds(17);
 }
 
 RenderThreadManager::RenderThreadManager(
@@ -128,11 +131,11 @@ void RenderThreadManager::ClientRequestInvokeGL(bool for_idle) {
       callback = request_draw_gl_closure_;
     }
     // 17ms is slightly longer than a frame, hoping that it will come
-    // after the next frame so that the idle work is taken care off by
+    // after the next frame so that the idle work is taken care of by
     // the next frame instead.
     ui_loop_->PostDelayedTask(
         FROM_HERE, std::move(callback),
-        for_idle ? base::TimeDelta::FromMilliseconds(17) : base::TimeDelta());
+        for_idle ? kSlightlyMoreThanOneFrame : base::TimeDelta());
   }
 }
 
@@ -251,6 +254,9 @@ void RenderThreadManager::InsertReturnedResourcesOnRT(
     const std::vector<viz::ReturnedResource>& resources,
     const CompositorID& compositor_id,
     uint32_t layer_tree_frame_sink_id) {
+  if (resources.empty())
+    return;
+
   base::AutoLock lock(lock_);
   ReturnedResources& returned_resources =
       returned_resources_map_[compositor_id];
@@ -260,6 +266,28 @@ void RenderThreadManager::InsertReturnedResourcesOnRT(
   returned_resources.resources.insert(returned_resources.resources.end(),
                                       resources.begin(), resources.end());
   returned_resources.layer_tree_frame_sink_id = layer_tree_frame_sink_id;
+
+  if (!returned_resource_available_pending_) {
+    returned_resource_available_pending_ = true;
+    ui_loop_->PostDelayedTask(
+        FROM_HERE,
+        base::BindOnce(&RenderThreadManager::ReturnedResourceAvailableOnUI,
+                       ui_thread_weak_ptr_),
+        kSlightlyMoreThanOneFrame * 2);
+  }
+}
+
+void RenderThreadManager::ReturnedResourceAvailableOnUI() {
+  bool empty = false;
+  {
+    base::AutoLock lock(lock_);
+    DCHECK(returned_resource_available_pending_);
+    returned_resource_available_pending_ = false;
+    empty = returned_resources_map_.empty();
+  }
+  if (!empty && compositor_frame_producer_) {
+    compositor_frame_producer_->ReturnedResourceAvailable(this);
+  }
 }
 
 void RenderThreadManager::SwapReturnedResourcesOnUI(

android_webview/browser/render_thread_manager.h

@@ -90,6 +90,7 @@ class RenderThreadManager : public CompositorFrameConsumer {
   void ResetRequestInvokeGLCallback();
   void ClientRequestInvokeGLOnUI();
   void UpdateParentDrawConstraintsOnUI();
+  void ReturnedResourceAvailableOnUI();
   bool IsInsideHardwareRelease() const;
   void SetInsideHardwareRelease(bool inside);
 
@@ -115,6 +116,7 @@ class RenderThreadManager : public CompositorFrameConsumer {
   ChildFrameQueue child_frames_;
   bool inside_hardware_release_;
   ParentCompositorDrawConstraints parent_draw_constraints_;
+  bool returned_resource_available_pending_ = false;
   ReturnedResourcesMap returned_resources_map_;
   base::RepeatingClosure request_draw_gl_closure_;