cc: Move pre-decodes to background worker.

cc/trees/layer_tree_host_unittest_checkerimaging.cc

 // Copyright 2017 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 "cc/base/completion_event.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
@@ skipping 63 matching lines @@
   }
 
   void ReadyToCommitOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_of_commits_ == 1) {
       // Send the blocked invalidation request before notifying that we're ready
       // to commit, since the invalidation will be merged with the commit.
       host_impl->BlockImplSideInvalidationRequestsForTesting(false);
     }
   }
 
+  void NotifyAllTileTasksCompleted(LayerTreeHostImpl* host_impl) override {
+    // Wait until all tile tasks have finished before flushing the decode tasks.
+    // The CheckerImageTracker does not queue decode work until higher priority
+    // raster work has finished.
+
+    // Run all tasks on the image worker to ensure that the decode completion
+    // triggers an impl-side invalidation request.
+    FlushImageDecodeTasks();
+
+    // Request a commit to ensure that this invalidation is merged with the
+    // incoming frame.
+    host_impl->GetTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&LayerTreeHostImpl::SetNeedsCommit,
+                              base::Unretained(host_impl)));
+  }
+
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     switch (++num_of_commits_) {
-      case 1: {
-        // The first commit has happened. Run all tasks on the image worker to
-        // ensure that the decode completion triggers an impl-side invalidation
-        // request.
-        FlushImageDecodeTasks();
-
-        // Block notifying the scheduler of this request until we get a commit.
+      case 1:
+        // Block notifying the scheduler of this request until we've had a
+        // chance to make sure that the decode work was scheduled, flushed and
+        // the commit requested after it is received.
         host_impl->BlockImplSideInvalidationRequestsForTesting(true);
-        host_impl->SetNeedsCommit();
-      } break;
+        break;
       case 2: {
         // Ensure that the expected tiles are invalidated on the sync tree.
         PictureLayerImpl* sync_layer_impl = static_cast<PictureLayerImpl*>(
             host_impl->sync_tree()->root_layer_for_testing());
         PictureLayerTiling* sync_tiling =
             sync_layer_impl->picture_layer_tiling_set()
                 ->FindTilingWithResolution(TileResolution::HIGH_RESOLUTION);
 
         for (int i = 0; i < 4; i++) {
+          SCOPED_TRACE(i);
           for (int j = 0; j < 2; j++) {
+            SCOPED_TRACE(j);
             Tile* tile =
                 sync_tiling->TileAt(i, j) ? sync_tiling->TileAt(i, j) : nullptr;
 
             // If this is the pending tree, then only the invalidated tiles
             // exist and have a raster task. If its the active tree, then only
             // the invalidated tiles have a raster task.
             if (i < 3) {
               EXPECT_TRUE(tile->HasRasterTask());
             } else if (host_impl->pending_tree()) {
               EXPECT_EQ(tile, nullptr);
@@ skipping 70 matching lines @@
 
   int num_of_activations_ = 0;
   int num_of_commits_ = 0;
   int num_of_impl_side_invalidations_ = 0;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCheckerImagingTestImplSideTree);
 
 }  // namespace
 }  // namespace cc