Delay activation/draw on GPU tile work completion

cc/tiles/tile_manager_unittest.cc

 // Copyright 2013 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.
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/playback/raster_source.h"
 #include "cc/playback/recording_source.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_compositor_frame_sink.h"
@@ skipping 1457 matching lines @@
    public:
     MockLayerTreeHostImpl(const LayerTreeSettings& settings,
                           TaskRunnerProvider* task_runner_provider,
                           TaskGraphRunner* task_graph_runner)
         : FakeLayerTreeHostImpl(settings,
                                 task_runner_provider,
                                 task_graph_runner) {}
 
     MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
     MOCK_METHOD0(NotifyReadyToDraw, void());
+    MOCK_METHOD0(NotifyReadyToActivate, void());
   };
 
   std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
       const LayerTreeSettings& settings,
       TaskRunnerProvider* task_runner_provider,
       TaskGraphRunner* task_graph_runner) override {
-    return base::MakeUnique<MockLayerTreeHostImpl>(
+    return base::MakeUnique<testing::NiceMock<MockLayerTreeHostImpl>>(
         settings, task_runner_provider, task_graph_runner);
   }
 
   // By default use software compositing (no context provider).
   std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
     return FakeCompositorFrameSink::CreateSoftware();
   }
 
   MockLayerTreeHostImpl& MockHostImpl() {
     return *static_cast<MockLayerTreeHostImpl*>(host_impl());
@@ skipping 375 matching lines @@
 TEST_F(PartialRasterTileManagerTest, PartialRasterSuccessfullyEnabled) {
   RunPartialRasterCheck(TakeHostImpl(), true /* partial_raster_enabled */);
 }
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(TakeHostImpl(), false /* partial_raster_enabled */);
 }
 
+// FakeRasterBufferProviderImpl that allows us to mock SetReadyToDrawCallback.
+class MockReadyToDrawRasterBufferProviderImpl
+    : public FakeRasterBufferProviderImpl {
+ public:
+  MOCK_CONST_METHOD3(
+      SetReadyToDrawCallback,
+      uint64_t(const ResourceProvider::ResourceIdArray& resource_ids,
+               const base::Callback<void(uint64_t)>& callback,
+               uint64_t pending_callback_id));
+};
+
+TEST_F(TileManagerTest, SmoothActivationWaitsOnCallback) {
+  MockReadyToDrawRasterBufferProviderImpl raster_buffer_provider;
+  host_impl()->tile_manager()->SetRasterBufferProviderForTesting(
+      &raster_buffer_provider);
+  host_impl()->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
+
+  base::Callback<void(uint64_t)> callback;
+  {
+    base::RunLoop run_loop;
+    EXPECT_CALL(raster_buffer_provider,
+                SetReadyToDrawCallback(testing::_, testing::_, 0))
+        .WillOnce(testing::Invoke([&run_loop, &callback](
+            const ResourceProvider::ResourceIdArray& resource_ids,
+            const base::Callback<void(uint64_t)>& callback_in,
+            uint64_t pending_callback_id) {
+          callback = callback_in;
+          run_loop.Quit();
+          return 1;
+        }));
+    host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+    run_loop.Run();
+  }
+
+  EXPECT_FALSE(host_impl()->tile_manager()->IsReadyToActivate());
+
+  {
+    base::RunLoop run_loop;
+    EXPECT_CALL(MockHostImpl(), NotifyReadyToActivate())
+        .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
+    callback.Run(1);
+    run_loop.Run();
+  }
+
+  EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToActivate());
+
+  TakeHostImpl();
+}
+
+TEST_F(TileManagerTest, SmoothActivationDoesNotWaitOnZeroCallback) {
+  MockReadyToDrawRasterBufferProviderImpl raster_buffer_provider;
+  host_impl()->tile_manager()->SetRasterBufferProviderForTesting(
+      &raster_buffer_provider);
+  host_impl()->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
+
+  base::RunLoop run_loop;
+  EXPECT_CALL(raster_buffer_provider,
+              SetReadyToDrawCallback(testing::_, testing::_, 0))
+      .WillOnce(testing::Return(0));
+  EXPECT_CALL(MockHostImpl(), NotifyReadyToActivate())
+      .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
+
+  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  run_loop.Run();
+
+  EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToActivate());
+
+  TakeHostImpl();
+}

[vmpstr, 2016/12/07 21:00:25]

Can you add a test for non-smoothness mode as well to make sure it doesn't wait
for anything

+
 }  // namespace
 }  // namespace cc