cc/tiles/decoded_image_tracker.cc

   1 // Copyright 2016 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/tiles/decoded_image_tracker.h"
   6 #include "base/trace_event/trace_event.h"
   7
   8 namespace cc {
   9 namespace {
  10 // Timeout images after 250ms, whether or not they've been used. This prevents
  11 // unbounded cache usage.
  12 const int64_t kTimeoutDurationMs = 250;
  13 }  // namespace
  14
  15 DecodedImageTracker::ImageLock::ImageLock(
  16     DecodedImageTracker* tracker,
  17     ImageController::ImageDecodeRequestId request_id,
  18     base::TimeTicks lock_time)
  19     : tracker_(tracker), request_id_(request_id), lock_time_(lock_time) {}
  20
  21 DecodedImageTracker::ImageLock::~ImageLock() {
  22   tracker_->image_controller_->UnlockImageDecode(request_id_);
  23 }
  24
  25 DecodedImageTracker::DecodedImageTracker(
  26     ImageController* controller,
  27     scoped_refptr<base::SequencedTaskRunner> task_runner)
  28     : image_controller_(controller),
  29       task_runner_(std::move(task_runner)),
  30       now_fn_(base::Bind(&base::TimeTicks::Now)),
  31       weak_ptr_factory_(this) {
  32   DCHECK(image_controller_);
  33 }
  34
  35 DecodedImageTracker::~DecodedImageTracker() {
  36   UnlockAllImages();
  37 }
  38
  39 void DecodedImageTracker::QueueImageDecode(
  40     const PaintImage& image,
  41     const gfx::ColorSpace& target_color_space,
  42     const base::Callback<void(bool)>& callback) {
  43   size_t frame_index = PaintImage::kDefaultFrameIndex;
  44   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
  45                "DecodedImageTracker::QueueImageDecode", "frame_key",
  46                image.GetKeyForFrame(frame_index).ToString());
  47   DCHECK(image_controller_);
  48   // Queue the decode in the image controller, but switch out the callback for
  49   // our own.
  50   auto image_bounds = SkIRect::MakeWH(image.width(), image.height());
  51   DrawImage draw_image(image, image_bounds, kNone_SkFilterQuality,
  52                        SkMatrix::I(), frame_index, target_color_space);
  53   image_controller_->QueueImageDecode(
  54       draw_image,
  55       base::Bind(&DecodedImageTracker::ImageDecodeFinished,
  56                  base::Unretained(this), callback, image.stable_id()));
  57 }
  58
  59 void DecodedImageTracker::UnlockAllImages() {
  60   locked_images_.clear();
  61 }
  62
  63 void DecodedImageTracker::OnImagesUsedInDraw(
  64     const std::vector<DrawImage>& draw_images) {
  65   for (const DrawImage& draw_image : draw_images)
  66     locked_images_.erase(draw_image.paint_image().stable_id());
  67 }
  68
  69 void DecodedImageTracker::ImageDecodeFinished(
  70     const base::Callback<void(bool)>& callback,
  71     PaintImage::Id image_id,
  72     ImageController::ImageDecodeRequestId request_id,
  73     ImageController::ImageDecodeResult result) {
  74   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
  75                "DecodedImageTracker::ImageDecodeFinished");
  76
  77   if (result == ImageController::ImageDecodeResult::SUCCESS) {
  78     // If this image already exists, just replace it with the new (latest)
  79     // decode.
  80     locked_images_.erase(image_id);
  81     locked_images_.emplace(
  82         image_id, std::make_unique<ImageLock>(this, request_id, now_fn_.Run()));
  83     EnqueueTimeout();
  84   }
  85   bool decode_succeeded =
  86       result == ImageController::ImageDecodeResult::SUCCESS ||
  87       result == ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED;
  88   callback.Run(decode_succeeded);
  89 }
  90
  91 void DecodedImageTracker::OnTimeoutImages() {
  92   timeout_pending_ = false;
  93   if (locked_images_.size() == 0)
  94     return;
  95
  96   auto now = now_fn_.Run();
  97   auto timeout = base::TimeDelta::FromMilliseconds(kTimeoutDurationMs);
  98   for (auto it = locked_images_.begin(); it != locked_images_.end();) {
  99     auto& image = it->second;
 100     if (now - image->lock_time() < timeout) {
 101       ++it;
 102       continue;
 103     }
 104     it = locked_images_.erase(it);
 105   }
 106
 107   EnqueueTimeout();
 108 }
 109
 110 void DecodedImageTracker::EnqueueTimeout() {
 111   if (timeout_pending_)
 112     return;
 113   if (locked_images_.size() == 0)
 114     return;
 115
 116   timeout_pending_ = true;
 117   task_runner_->PostDelayedTask(
 118       FROM_HERE,
 119       base::Bind(&DecodedImageTracker::OnTimeoutImages,
 120                  weak_ptr_factory_.GetWeakPtr()),
 121       base::TimeDelta::FromMilliseconds(kTimeoutDurationMs));
 122 }
 123
 124 }  // namespace cc