cc/blink: Veto checker-imaging for multipart image resources.

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());
 }
 
 std::string ToString(PaintImage::Id paint_image_id,
                      SkImageId sk_image_id,
                      bool complete,
                      bool static_image,
                      bool fits_size_constraints,
+                     bool is_multipart,
                      size_t size) {
   std::ostringstream str;
   str << "paint_image_id[" << paint_image_id << "] sk_image_id[" << sk_image_id
       << "] complete[" << complete << "] static[" << static_image
       << "], fits_size_constraints[" << fits_size_constraints << "], size["
-      << size << "]";
+      << size << "]"
+      << " is_multipart[" << is_multipart << "]";
   return str.str();
 }
 
 }  // namespace
 
 CheckerImageTracker::CheckerImageTracker(ImageController* image_controller,
                                          CheckerImageTrackerClient* client,
                                          bool enable_checker_imaging)
     : image_controller_(image_controller),
       client_(client),
@@ skipping 128 matching lines @@
   if (insert_result.second) {
     bool complete =
         image.completion_state() == PaintImage::CompletionState::DONE;
     bool static_image =
         image.animation_type() == PaintImage::AnimationType::STATIC;
     size_t size = SafeSizeOfImage(image.sk_image().get());
     bool fits_size_constraints =
         size >= kMinImageSizeToCheckerBytes &&
         size <= image_controller_->image_cache_max_limit_bytes();
 
-    // Only checker images that are static and completely loaded and fit within
-    // the size constraints.
-    bool can_checker_image = complete && static_image && fits_size_constraints;
+    // The following conditions must be true for an image to be checkerable:
+    //
+    // 1) Complete: The data for the image should have been completely loaded.
+    //
+    // 2) Static: Animated images/video frames can not be checkered.
+    //
+    // 3) Size constraints: Small images for which the decode is expected to
+    // be fast and large images which would breach the image cache budget and
+    // go through the at-raster decode path are not checkered.
+    //
+    // 4) Multipart images: Multipart images can be used to display mjpg video
+    // frames, checkering which would cause each video frame to flash and
+    // therefore should not be checkered.
+    bool can_checker_image = complete && static_image &&
+                             fits_size_constraints && !image.is_multipart();
     if (can_checker_image)
       it->second.policy = DecodePolicy::ASYNC;
 
-    TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "CheckerImageTracker::CheckerImagingDecision",
-                 "can_checker_image", can_checker_image, "image_params",
-                 ToString(image_id, image.sk_image()->uniqueID(), complete,
-                          static_image, fits_size_constraints, size));
+    TRACE_EVENT2(
+        TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+        "CheckerImageTracker::CheckerImagingDecision", "can_checker_image",
+        can_checker_image, "image_params",
+        ToString(image_id, image.sk_image()->uniqueID(), complete, static_image,
+                 fits_size_constraints, image.is_multipart(), size));
   }
 
   // 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;
 }
 
@@ skipping 69 matching lines @@
   ImageController::ImageDecodeRequestId request_id =
       image_controller_->QueueImageDecode(
           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