cc: Add scaling for checkered images.

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 72 matching lines @@
 
   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.policy, DecodePolicy::SYNC_DECODED_ONCE);
 
-      it->second = DecodePolicy::ASYNC;
+      it->second.policy = DecodePolicy::ASYNC;
     }
   }
   images_pending_invalidation_.clear();
 }
 
 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.policy = DecodePolicy::SYNC_DECODED_ONCE;
   images_pending_invalidation_.insert(image_id);
   ScheduleNextImageDecode();
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
-bool CheckerImageTracker::ShouldCheckerImage(const PaintImage& image,
+bool CheckerImageTracker::ShouldCheckerImage(const DrawImage& draw_image,
                                              WhichTree tree) {
+  const PaintImage& image = draw_image.paint_image();
+  PaintImage::Id image_id = image.stable_id();
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
-               image.stable_id());
+               image_id);
 
   if (!enable_checker_imaging_)
     return false;
 
-  PaintImage::Id image_id = image.stable_id();
-
   // 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_id) != 0 &&
       tree == WhichTree::ACTIVE_TREE) {
     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, DecodeState>(image_id, DecodeState()));
   auto it = insert_result.first;
   if (insert_result.second) {
-    bool can_checker_image =
-        image.animation_type() == PaintImage::AnimationType::STATIC &&
+    bool complete =
         image.completion_state() == PaintImage::CompletionState::DONE;
-    if (can_checker_image) {
+    bool static_image =
+        image.animation_type() == PaintImage::AnimationType::STATIC;
+    // Only checker images that are static and completely loaded.
+    if (complete && static_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;
+      bool too_small = size < kMinImageSizeToCheckerBytes;
+      bool too_large = size > image_controller_->image_cache_max_limit_bytes();
+      it->second.policy = (too_small || too_large)

[ericrk, 2017/06/06 22:39:51]

The policy already defaults to SYNC_PERMANENT, and you rely on this in the other
branch. Maybe cleaner to just say:

if (!too_small && !too_large)
  it->second.policy = DecodePolicy::ASYNC

Or might be cleaner to just pull these out and have a single if statement? WDYT?

[Khushal, 2017/06/07 00:43:31]

How does it look now? I broke the size part seperately because I wanted to
capture what causes the veto in the trace. Looks cleaner too now.

+                              ? DecodePolicy::SYNC_PERMANENT
+                              : DecodePolicy::ASYNC;
+      TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+                   "CheckerImageTracker::CheckerImagingDecision", "too_small",
+                   too_small, "too_large", too_large);
+    } else {
+      TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+                   "CheckerImageTracker::CanNotChecker", "complete", complete,
+                   "static", static_image);

[ericrk, 2017/06/06 22:39:51]

nit: The naming of these trace values seems a bit odd - doesn't too_small /
too_large also mean we can't checker? Why is that tracked separately from
CanNotChecker?

[Khushal, 2017/06/07 00:43:31]

You're right. Its because I went to look for TRACE_EVENT3. :P Now I see there is
a better way.

     }
   }
 
-  return it->second == DecodePolicy::ASYNC;
+  // Update the decode state from the latest image we have seen. Note that it
+  // is not necessary to perform this in the early out cases above since in
+  // each of those cases the image has already been decoded.
+  UpdateDecodeState(draw_image, image_id, &it->second);
+
+  return it->second.policy == DecodePolicy::ASYNC;
+}
+
+void CheckerImageTracker::UpdateDecodeState(const DrawImage& draw_image,
+                                            PaintImage::Id paint_image_id,
+                                            DecodeState* decode_state) {
+  // If the policy is not async then either we decoded this image already or
+  // we decided not to ever checker it.
+  if (decode_state->policy != DecodePolicy::ASYNC)
+    return;
+
+  // If the decode is already in flight, then we will have to live with what we
+  // have now.
+  if (outstanding_image_decode_.has_value() &&
+      outstanding_image_decode_.value().stable_id() == paint_image_id) {
+    return;
+  }
+
+  // Choose the max scale, going up till the original decode size, and filter
+  // quality. This keeps the memory usage to the minimum possible while still
+  // increasing the possibility of getting a cache hit.
+  decode_state->scale.fWidth = std::min(

[ericrk, 2017/06/06 22:39:51]

Do we really not want to scale up at this point? This has no impact on GPU
(which will never scale over 1, even if requested), but seems like it could be
nice for SW, getting a potentially expensive scale out of the way? Or does the
memory usage outweigh the potential perf gains?

[Khushal, 2017/06/07 00:43:31]

I don't think the memory impact would be much. Now that I think about it, it
might be better since right now we keep the original decode locked in addition
to the scaled version. There is a possibility that if we see the same image with
different scales and high filter quality then the software cache wouldn't use
it, because it takes the exact scale value (could happen during pinch-zoom). But
I guess we can consider that case rare enough to not avoid avoid the performance
benefit of scaling.

+      1.0f, std::max(decode_state->scale.fWidth, draw_image.scale().fWidth));
+  decode_state->scale.fHeight = std::min(

[ericrk, 2017/06/06 22:39:51]

Is this ever called with a non-default DecodeState? do you need to consider the
decode_state scale value? 

[Khushal, 2017/06/07 00:43:31]

It will be called with a non-default state if we see 2 calls for the same
PaintImage. That's why its keeping the max of what we have seen so far.

+      1.0f, std::max(decode_state->scale.fHeight, draw_image.scale().fHeight));
+  decode_state->filter_quality =
+      std::max(decode_state->filter_quality, draw_image.filter_quality());
+  decode_state->color_space = draw_image.target_color_space();
 }
 
 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
   // service. We'll come back here when it is completed.
   if (outstanding_image_decode_.has_value())
     return;
 
+  DrawImage draw_image;
   while (!image_decode_queue_.empty()) {
     auto candidate = std::move(image_decode_queue_.front());
     image_decode_queue_.erase(image_decode_queue_.begin());
 
     // Once an image has been decoded, it can still be present in the decode
     // queue (duplicate entries), or while an image is still being skipped on
     // the active tree. Check if the image is still ASYNC to see if a decode is
     // needed.
     PaintImage::Id image_id = candidate.stable_id();
     auto it = image_async_decode_state_.find(image_id);
     DCHECK(it != image_async_decode_state_.end());
-    if (it->second != DecodePolicy::ASYNC)
+    if (it->second.policy != DecodePolicy::ASYNC)
       continue;
 
+    draw_image = DrawImage(candidate, candidate.sk_image()->bounds(),
+                           it->second.filter_quality,
+                           SkMatrix::MakeScale(it->second.scale.width(),
+                                               it->second.scale.height()),
+                           it->second.color_space);
     outstanding_image_decode_.emplace(candidate);
     break;
   }
 
   // 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_.has_value()) {
     DCHECK(image_decode_queue_.empty());
     return;
   }
 
   PaintImage::Id image_id = outstanding_image_decode_.value().stable_id();
   DCHECK_EQ(image_id_to_decode_.count(image_id), 0u);
   TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode",
                            image_id);
   ImageController::ImageDecodeRequestId request_id =
       image_controller_->QueueImageDecode(
-          outstanding_image_decode_.value().sk_image(),
-          base::Bind(&CheckerImageTracker::DidFinishImageDecode,
-                     weak_factory_.GetWeakPtr(), image_id));
+          draw_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