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

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/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 70 matching lines @@
   // they should be accompanied with an invalidation during paint.
   image_id_to_decode_.clear();
 
   if (can_clear_decode_policy_tracking) {
     image_async_decode_state_.clear();
   } else {
     // If we can't clear the decode policy, we need to make sure we still
     // re-decode and checker images that were pending invalidation.
     for (auto image_id : images_pending_invalidation_) {
       auto it = image_async_decode_state_.find(image_id);
+      DCHECK(it != image_async_decode_state_.end());
 
-      DCHECK(it != image_async_decode_state_.end());
+      // We might have disallowed checkering for this image while it was pending
+      // invalidation. Ensure that we keep this information.
+      if (it->second == DecodePolicy::SYNC_PERMANENT)
+        continue;
+
       DCHECK_EQ(it->second, DecodePolicy::SYNC_DECODED_ONCE);
-
       it->second = DecodePolicy::ASYNC;
     }
   }
   images_pending_invalidation_.clear();
 }
 
+void CheckerImageTracker::DisallowCheckeringForImage(const PaintImage& image) {
+  image_async_decode_state_[image.stable_id()] = DecodePolicy::SYNC_PERMANENT;

[Khushal, 2017/06/07 00:47:21]

I think if the image was already seen by the tracker, then we have to continue
checkering it. Because we now we have checker-imaged tiles and we are
responsible for invalidating them.

[vmpstr, 2017/06/07 17:05:35]

Makes sense. I've added a separate container for tracking this so that it
doesn't get muddied with the current state. The new behavior should be that if
we already know the state of the image in the decode state, then it will use
that. However, when inserting a new state it will consider whether it's
disallowed or not.

I've also changed the clear function a little bit so that instead of marking
images as async if they were sync decoded with pending invalidations, instead
they just get deleted from the state. This would again make then async when we
check if we should checker them, unless of course they were disallowed
meanwhile. I think this is fine, since we clear the pending invalidation set
anyway, so we know there are no tiles right now. Is that correct? 

In other words, if we are "soft" clearing the tracker, then that means we're not
visible which means we've evicted all tiles. If that wouldn't be the case, then
we can't clear the images pending invalidation, afaict.

+}
+
 void CheckerImageTracker::DidFinishImageDecode(
     PaintImage::Id 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(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED, result);
   DCHECK_EQ(outstanding_image_decode_.value().stable_id(), image_id);
   outstanding_image_decode_.reset();
 
   // The async decode state may have been cleared if the tracker was cleared
   // before this decode could be finished.
   auto it = image_async_decode_state_.find(image_id);
   if (it == image_async_decode_state_.end()) {
     DCHECK_EQ(image_id_to_decode_.count(image_id), 0u);
     return;
   }
 
-  it->second = DecodePolicy::SYNC_DECODED_ONCE;
+  // We might have disallowed checkering for this image while it was being
+  // processed. Ensure that the stronger condition is recorded.
+  if (it->second != DecodePolicy::SYNC_PERMANENT)
+    it->second = DecodePolicy::SYNC_DECODED_ONCE;
   images_pending_invalidation_.insert(image_id);
   ScheduleNextImageDecode();
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
 bool CheckerImageTracker::ShouldCheckerImage(const PaintImage& image,
                                              WhichTree tree) {
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
                image.stable_id());
 
@@ skipping 78 matching lines @@
       image_controller_->QueueImageDecode(
           outstanding_image_decode_.value().sk_image(),
           base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                      weak_factory_.GetWeakPtr(), image_id));
 
   image_id_to_decode_.emplace(image_id, base::MakeUnique<ScopedDecodeHolder>(
                                             image_controller_, request_id));
 }
 
 }  // namespace cc