cc: Use an enum for tracking images vetoed for async decodes.

cc/tiles/checker_image_tracker.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/tiles/checker_image_tracker.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 
@@ skipping 74 matching lines @@
     ImageId image_id,
     ImageController::ImageDecodeRequestId request_id,
     ImageController::ImageDecodeResult result) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::DidFinishImageDecode");
   TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode",
                          image_id);
 
   DCHECK_NE(result, ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED);
   DCHECK_NE(pending_image_decodes_.count(image_id), 0u);
+  DCHECK_NE(image_async_decode_state_.count(image_id), 0u);
+
   pending_image_decodes_.erase(image_id);
 
-  images_decoded_once_.insert(image_id);
+  image_async_decode_state_[image_id] = AsyncDecodeVetoState::SYNC_DECODED_ONCE;
   images_pending_invalidation_.insert(image_id);
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
 bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image,
-                                             WhichTree tree) const {
+                                             WhichTree tree) {
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
                image->uniqueID());
 
   if (!enable_checker_imaging_)
     return false;
 
   // If the image was invalidated on the current sync tree and the tile is
   // for the active tree, continue checkering it on the active tree to ensure
   // the image update is atomic for the frame.
   if (invalidated_images_on_current_sync_tree_.count(image->uniqueID()) != 0 &&
       tree == WhichTree::ACTIVE_TREE) {
     return true;
   }
 
-  // If a decode request is pending for this image, continue checkering it.
-  if (pending_image_decodes_.find(image->uniqueID()) !=
-      pending_image_decodes_.end()) {
-    return true;
-  }
-
   // If the image is pending invalidation, continue checkering it. All tiles
   // for these images will be invalidated on the next pending tree.
   if (images_pending_invalidation_.find(image->uniqueID()) !=
       images_pending_invalidation_.end()) {
     return true;
   }
 
-  // If the image has been decoded once before, don't checker it again.
-  if (images_decoded_once_.find(image->uniqueID()) !=
-      images_decoded_once_.end()) {
-    return false;
+  ImageId image_id = image->uniqueID();
+  if (image_async_decode_state_.find(image_id) ==
+      image_async_decode_state_.end()) {
+    image_async_decode_state_[image_id] =
+        SafeSizeOfImage(image.get()) >= kMinImageSizeToCheckerBytes
+            ? AsyncDecodeVetoState::ASYNC
+            : AsyncDecodeVetoState::SYNC_PERMANENT;
   }
 
-  return SafeSizeOfImage(image.get()) >= kMinImageSizeToCheckerBytes;
+  return image_async_decode_state_[image_id] == AsyncDecodeVetoState::ASYNC;

[vmpstr, 2017/04/11 18:42:55]

Erm, in lines 128-136 you do 3 finds on the same image. Can you cache some of
the results

[Khushal, 2017/04/12 20:31:17]

Done.

 }
 
 void CheckerImageTracker::ScheduleImageDecodeIfNecessary(
     const sk_sp<const SkImage>& image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::ScheduleImageDecodeIfNecessary");
   ImageId image_id = image->uniqueID();
 
-  // If the image has already been decoded, or a decode request is pending, we
-  // don't need to schedule another decode.
-  if (images_decoded_once_.count(image_id) != 0 ||
-      pending_image_decodes_.count(image_id) != 0) {
+  // The image might have already been decoded, in which case we don't need to

[vmpstr, 2017/04/11 18:42:55]

Can you reword the comment to take into account that we're not checking whether
it's been decoded, rather we're checking if it can be async

[Khushal, 2017/04/12 20:31:17]

Done.

+  // request another decode.
+  DCHECK_NE(image_async_decode_state_.count(image_id), 0u);
+  if (image_async_decode_state_[image_id] != AsyncDecodeVetoState::ASYNC)
+    return;
+
+  // If a decode request is pending, we don't need to schedule another decode.
+  if (pending_image_decodes_.count(image_id) != 0) {
     return;
   }
 
   TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode",
                            image_id);
   DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0U);
 
   image_id_to_decode_request_id_[image_id] =
       image_controller_->QueueImageDecode(
           image, base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                             weak_factory_.GetWeakPtr(), image_id));
   pending_image_decodes_.insert(image_id);
 }
 
 }  // namespace cc