cc: Clear checker-image tracking on navigation and visibility changes.

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"
 
 namespace cc {
 namespace {
 // The minimum size of an image that we should consider checkering.
 size_t kMinImageSizeToCheckerBytes = 512 * 1024;
 
 size_t SafeSizeOfImage(const SkImage* image) {
   base::CheckedNumeric<size_t> checked_size = 4;
   checked_size *= image->width();
   checked_size *= image->height();
   return checked_size.ValueOrDefault(std::numeric_limits<size_t>::max());
 }
 
 }  // namespace
 
 CheckerImageTracker::CheckerImageTracker(ImageController* image_controller,
                                          CheckerImageTrackerClient* client,
                                          bool enable_checker_imaging)
     : image_controller_(image_controller),
       client_(client),
       enable_checker_imaging_(enable_checker_imaging),
       weak_factory_(this) {}
 
-CheckerImageTracker::~CheckerImageTracker() {
-  // Unlock all images pending decode requests.
-  for (auto it : image_id_to_decode_request_id_)
-    image_controller_->UnlockImageDecode(it.second);
-}
+CheckerImageTracker::~CheckerImageTracker() = default;
 
 void CheckerImageTracker::ScheduleImageDecodeQueue(
     ImageDecodeQueue image_decode_queue) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::ScheduleImageDecodeQueue");
   // Only checker-imaged (async updated) images are decoded using the image
   // decode service. If |enable_checker_imaging_| is false, no image should
   // be checkered.
   DCHECK(image_decode_queue.empty() || enable_checker_imaging_);
 
   image_decode_queue_ = std::move(image_decode_queue);
   ScheduleNextImageDecode();
 }
 
 const ImageIdFlatSet& CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::TakeImagesToInvalidateOnSyncTree");
   DCHECK_EQ(invalidated_images_on_current_sync_tree_.size(), 0u)
       << "Sync tree can not be invalidated more than once";
 
   invalidated_images_on_current_sync_tree_.swap(images_pending_invalidation_);
   images_pending_invalidation_.clear();
   return invalidated_images_on_current_sync_tree_;
 }
 
 void CheckerImageTracker::DidActivateSyncTree() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::DidActivateSyncTree");
-  for (auto image_id : invalidated_images_on_current_sync_tree_) {
-    auto it = image_id_to_decode_request_id_.find(image_id);
-    image_controller_->UnlockImageDecode(it->second);
-    image_id_to_decode_request_id_.erase(it);
+  for (auto image_id : invalidated_images_on_current_sync_tree_)
+    image_id_to_decode_.erase(image_id);
+  invalidated_images_on_current_sync_tree_.clear();
+}
+
+void CheckerImageTracker::ClearTracker(bool can_clear_decode_policy_tracking) {
+  // Unlock all images and tracking for images pending invalidation. The
+  // |images_invalidated_on_current_sync_tree_| will be cleared when the sync
+  // tree is activated.
+  //
+  // Note that we assume that any images with DecodePolicy::ASYNC, which may be
+  // checkered, are safe to stop tracking here and will either be re-checkered
+  // and invalidated when the decode completes or be invalidated externally.
+  // This is because the policy decision for checkering an image is based on
+  // inputs received from a PaintImage in the DisplayItemList. The policy chosen
+  // for a PaintImage should remain unchanged.
+  // If the external inputs for deciding the decode policy for an image change,
+  // 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_) {

[Khushal, 2017/05/13 03:24:43]

Realized I was missing this case. I've added a test for this as well. Do you
mind taking another look?

+      auto it = image_async_decode_state_.find(image_id);
+
+      DCHECK(it != image_async_decode_state_.end());
+      DCHECK_EQ(it->second, DecodePolicy::SYNC_DECODED_ONCE);
+
+      it->second = DecodePolicy::ASYNC;
+    }
   }
-
-  invalidated_images_on_current_sync_tree_.clear();
+  images_pending_invalidation_.clear();
 }
 
 void CheckerImageTracker::DidFinishImageDecode(
     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(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED, result);
   DCHECK_EQ(outstanding_image_decode_->uniqueID(), image_id);
+  outstanding_image_decode_ = nullptr;
 
-  outstanding_image_decode_ = nullptr;
-  image_async_decode_state_[image_id] = DecodePolicy::SYNC_DECODED_ONCE;
+  // 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;
   images_pending_invalidation_.insert(image_id);
-
   ScheduleNextImageDecode();
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
 bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image,
                                              WhichTree tree) {
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
                image->uniqueID());
 
   if (!enable_checker_imaging_)
@@ skipping 56 matching lines @@
   }
 
   // We either found an image to decode or we reached the end of the queue. If
   // we couldn't find an image, we're done.
   if (!outstanding_image_decode_) {
     DCHECK(image_decode_queue_.empty());
     return;
   }
 
   ImageId image_id = outstanding_image_decode_->uniqueID();
-  DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0u);
+  DCHECK_EQ(image_id_to_decode_.count(image_id), 0u);
   TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode",
                            image_id);
-  image_id_to_decode_request_id_[image_id] =
+  ImageController::ImageDecodeRequestId request_id =
       image_controller_->QueueImageDecode(
           outstanding_image_decode_,
           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