Removed several levels of calls to RenderWidget::DidReceiveCompositorFrameAck.

Bug: 725061
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I9bec1e76635379dd7a09a5160e1dff69074692f9
Reviewed-on: https://chromium-review.googlesource.com/1183232Reviewed-by: Camille Lamy <clamy@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Commit-Queue: Karolina Soltys <ksolt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595498}

cc/trees/layer_tree_host_unittest.cc

@@ -8917,5 +8917,40 @@ class LayerTreeHostTestNewLocalSurfaceIdForcesDraw : public LayerTreeHostTest {
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNewLocalSurfaceIdForcesDraw);
 
+// Verifies that DidReceiveCompositorFrameAck does not get sent with PostTask
+// when not needed.
+class DidReceiveCompositorFrameAckNotSentWhenNotNeeded
+    : public LayerTreeHostTest {
+ public:
+  DidReceiveCompositorFrameAckNotSentWhenNotNeeded() {}
+
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->send_compositor_frame_ack = false;
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void DidReceiveCompositorFrameAck() override { ADD_FAILURE(); }
+
+  // DrawLayersOnThread gets called after the conditional call to
+  // DidReceiveCompositorFrameAck, so we wait for it to end the test.
+  void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
+    if (!received_first_frame_) {
+      received_first_frame_ = true;
+      PostSetNeedsCommitToMainThread();
+    } else {
+      EndTest();
+    }
+  }
+
+  void AfterTest() override {}
+
+ private:
+  bool received_first_frame_ = false;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    DidReceiveCompositorFrameAckNotSentWhenNotNeeded);
+
 }  // namespace
 }  // namespace cc

cc/trees/layer_tree_settings.h

@@ -160,6 +160,11 @@ class CC_EXPORT LayerTreeSettings {
   // When false, sync tokens are expected to be present, and are verified,
   // before transfering gpu resources to the display compositor.
   bool delegated_sync_points_required = true;
+
+  // When true, LayerTreeHostImplClient will be posting a task to call
+  // DidReceiveCompositorFrameAck, used by the Compositor but not the
+  // LayerTreeView.
+  bool send_compositor_frame_ack = true;
 };
 
 }  // namespace cc

cc/trees/proxy_impl.cc

@@ -69,6 +69,7 @@ ProxyImpl::ProxyImpl(base::WeakPtr<ProxyMain> proxy_main_weak_ptr,
 
   host_impl_ = layer_tree_host->CreateLayerTreeHostImpl(this);
   const LayerTreeSettings& settings = layer_tree_host->GetSettings();
+  send_compositor_frame_ack_ = settings.send_compositor_frame_ack;
 
   SchedulerSettings scheduler_settings(settings.ToSchedulerSettings());
 
@@ -291,9 +292,11 @@ void ProxyImpl::DidReceiveCompositorFrameAckOnImplThread() {
                "ProxyImpl::DidReceiveCompositorFrameAckOnImplThread");
   DCHECK(IsImplThread());
   scheduler_->DidReceiveCompositorFrameAck();
-  MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::BindOnce(&ProxyMain::DidReceiveCompositorFrameAck,
-                                proxy_main_frame_sink_bound_weak_ptr_));
+  if (send_compositor_frame_ack_) {
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE, base::BindOnce(&ProxyMain::DidReceiveCompositorFrameAck,
+                                  proxy_main_frame_sink_bound_weak_ptr_));
+  }
 }
 
 void ProxyImpl::OnCanDrawStateChanged(bool can_draw) {

cc/trees/proxy_impl.h

@@ -153,6 +153,8 @@ class CC_EXPORT ProxyImpl : public LayerTreeHostImplClient,
   bool inside_draw_;
   bool input_throttled_until_commit_;
 
+  bool send_compositor_frame_ack_;
+
   TaskRunnerProvider* task_runner_provider_;
 
   DelayedUniqueNotifier smoothness_priority_expiration_notifier_;

cc/trees/single_thread_proxy.cc

@@ -442,12 +442,14 @@ void SingleThreadProxy::DidReceiveCompositorFrameAckOnImplThread() {
                "SingleThreadProxy::DidReceiveCompositorFrameAckOnImplThread");
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidReceiveCompositorFrameAck();
-  // We do a PostTask here because freeing resources in some cases (such as in
-  // TextureLayer) is PostTasked and we want to make sure ack is received after
-  // resources are returned.
-  task_runner_provider_->MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&SingleThreadProxy::DidReceiveCompositorFrameAck,
-                            frame_sink_bound_weak_ptr_));
+  if (layer_tree_host_->GetSettings().send_compositor_frame_ack) {
+    // We do a PostTask here because freeing resources in some cases (such as in
+    // TextureLayer) is PostTasked and we want to make sure ack is received
+    // after resources are returned.
+    task_runner_provider_->MainThreadTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&SingleThreadProxy::DidReceiveCompositorFrameAck,
+                              frame_sink_bound_weak_ptr_));
+  }
 }
 
 void SingleThreadProxy::OnDrawForLayerTreeFrameSink(

content/renderer/gpu/layer_tree_view.cc

@@ -669,10 +669,6 @@ void LayerTreeView::DidCommitAndDrawFrame() {
   delegate_->DidCommitAndDrawCompositorFrame();
 }
 
-void LayerTreeView::DidReceiveCompositorFrameAck() {
-  delegate_->DidReceiveCompositorFrameAck();
-}
-
 void LayerTreeView::DidCompletePageScaleAnimation() {
   delegate_->DidCompletePageScaleAnimation();
 }

content/renderer/gpu/layer_tree_view.h

@@ -192,7 +192,7 @@ class CONTENT_EXPORT LayerTreeView
   void WillCommit() override;
   void DidCommit() override;
   void DidCommitAndDrawFrame() override;
-  void DidReceiveCompositorFrameAck() override;
+  void DidReceiveCompositorFrameAck() override {}
   void DidCompletePageScaleAnimation() override;
   void DidPresentCompositorFrame(
       uint32_t frame_token,

content/renderer/gpu/layer_tree_view_delegate.h

@@ -65,10 +65,6 @@ class LayerTreeViewDelegate {
   // Called by the compositor when page scale animation completed.
   virtual void DidCompletePageScaleAnimation() = 0;
 
-  // Notifies that the last submitted CompositorFrame has been processed and
-  // will be displayed.
-  virtual void DidReceiveCompositorFrameAck() = 0;
-
   // Requests that a UMA and UKM metric be recorded for the total frame time.
   // Call this as soon as the total frame time becomes known for a given frame.
   // For example, ProxyMain::BeginMainFrame calls it immediately before aborting

content/renderer/render_widget.cc

@@ -1013,9 +1013,6 @@ void RenderWidget::DidCompletePageScaleAnimation() {
     owner_delegate_->DidCompletePageScaleAnimationForWidget();
 }
 
-void RenderWidget::DidReceiveCompositorFrameAck() {
-}
-
 bool RenderWidget::IsClosing() const {
   // TODO(ajwong): There is oddly 2 closing states. This API is used by
   // LayerTreeView only as part of the LayerTreeViewDelegate interface and
@@ -2782,6 +2779,9 @@ cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
 
   settings.always_request_presentation_time =
       cmd.HasSwitch(cc::switches::kAlwaysRequestPresentationTime);
+
+  settings.send_compositor_frame_ack = false;
+
   return settings;
 }
 

content/renderer/render_widget.h

@@ -270,7 +270,6 @@ class CONTENT_EXPORT RenderWidget
   void DidCommitAndDrawCompositorFrame() override;
   void DidCommitCompositorFrame() override;
   void DidCompletePageScaleAnimation() override;
-  void DidReceiveCompositorFrameAck() override;
   void RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) override;
   bool IsClosing() const override;
   void RequestScheduleAnimation() override;

content/test/stub_layer_tree_view_delegate.h

@@ -26,7 +26,6 @@ class StubLayerTreeViewDelegate : public LayerTreeViewDelegate {
   void DidCommitAndDrawCompositorFrame() override {}
   void DidCommitCompositorFrame() override {}
   void DidCompletePageScaleAnimation() override {}
-  void DidReceiveCompositorFrameAck() override {}
   bool IsClosing() const override;
   void RequestScheduleAnimation() override {}
   void UpdateVisualState() override {}