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_EQ(it->second, DecodePolicy::SYNC_DECODED_ONCE);
-
+      DCHECK_EQ(it->second, DecodePolicy::SYNC);
       it->second = DecodePolicy::ASYNC;
     }
   }
   images_pending_invalidation_.clear();
 }
 
+void CheckerImageTracker::DisallowCheckeringForImage(const PaintImage& image) {
+  image_async_decode_state_.insert(
+      std::make_pair(image.stable_id(), DecodePolicy::SYNC));
+}
+
 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;
+  it->second = DecodePolicy::SYNC;
   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 10 matching lines @@
     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_id) !=
       images_pending_invalidation_.end()) {
     return true;
   }
 
-  auto insert_result =
-      image_async_decode_state_.insert(std::pair<PaintImage::Id, DecodePolicy>(
-          image_id, DecodePolicy::SYNC_PERMANENT));
+  auto insert_result = image_async_decode_state_.insert(
+      std::pair<PaintImage::Id, DecodePolicy>(image_id, DecodePolicy::SYNC));
   auto it = insert_result.first;
   if (insert_result.second) {
     bool can_checker_image =
         image.animation_type() == PaintImage::AnimationType::STATIC &&
         image.completion_state() == PaintImage::CompletionState::DONE;
     if (can_checker_image) {
       size_t size = SafeSizeOfImage(image.sk_image().get());
       it->second = (size >= kMinImageSizeToCheckerBytes &&
                     size <= image_controller_->image_cache_max_limit_bytes())
                        ? DecodePolicy::ASYNC
-                       : DecodePolicy::SYNC_PERMANENT;
+                       : DecodePolicy::SYNC;
     }
   }
 
   return it->second == DecodePolicy::ASYNC;
 }
 
 void CheckerImageTracker::ScheduleNextImageDecode() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::ScheduleNextImageDecode");
   // We can have only one outsanding decode pending completion with the decode
@@ skipping 34 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