cc: Disallow img.decode images from being checker imaged.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 7776 matching lines @@
   BeginFrameArgs current_begin_main_frame_args_on_impl_;
   LayerTreeHostImpl::FrameData* frame_data_;
 };
 
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostTestBeginFrameSequenceNumbers);
 
 class LayerTreeHostTestQueueImageDecode : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->enable_checker_imaging = true;
+  }
+
   void WillBeginMainFrame() override {
     if (!first_)
       return;
     first_ = false;
 
-    PaintImage image(PaintImage::GetNextId(),
-                     CreateDiscardableImage(gfx::Size(10, 10)));
+    image_ = PaintImage(PaintImage::GetNextId(),
+                        CreateDiscardableImage(gfx::Size(400, 400)));
     auto callback =
         base::Bind(&LayerTreeHostTestQueueImageDecode::ImageDecodeFinished,
                    base::Unretained(this));
     // Schedule the decode twice for the same image.
-    layer_tree_host()->QueueImageDecode(image, callback);
-    layer_tree_host()->QueueImageDecode(image, callback);
+    layer_tree_host()->QueueImageDecode(image_, callback);
+    layer_tree_host()->QueueImageDecode(image_, callback);
+  }
+
+  void ReadyToCommitOnThread(LayerTreeHostImpl* impl) override {
+    if (one_commit_done_)
+      return;
+    EXPECT_TRUE(
+        impl->tile_manager()->checker_image_tracker().ShouldCheckerImage(
+            image_, WhichTree::PENDING_TREE));
+  }
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
+    one_commit_done_ = true;
+    EXPECT_FALSE(
+        impl->tile_manager()->checker_image_tracker().ShouldCheckerImage(
+            image_, WhichTree::PENDING_TREE));
   }
 
   void ImageDecodeFinished(bool decode_succeeded) {
     EXPECT_TRUE(decode_succeeded);
     ++finished_decode_count_;
     EXPECT_LE(finished_decode_count_, 2);
     if (finished_decode_count_ == 2)
       EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   bool first_ = true;
+  bool one_commit_done_ = false;
   int finished_decode_count_ = 0;
+  PaintImage image_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestQueueImageDecode);
 
 class LayerTreeHostTestQueueImageDecodeNonLazy : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginMainFrame() override {
     if (!first_)
@@ skipping 134 matching lines @@
   void AfterTest() override {}
 
  private:
   bool received_ack_ = false;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDiscardAckAfterRelease);
 
 }  // namespace
 }  // namespace cc