cc: Add image decode control in the compositor.

cc/tiles/image_decode_controller.cc

 // Copyright 2015 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/image_decode_controller.h"
 
+#include "base/memory/discardable_memory.h"
 #include "cc/debug/devtools_instrumentation.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImage.h"
 
 namespace cc {
 namespace {
 
+// The amount of memory we can lock ahead of time (128MB). This limit is only
+// used to inform the caller of the amount of space available in the cache. The
+// caller can still request tasks which can cause this limit to be breached.
+const size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024;
+
+// The largest single high quality image to try and process. Images above this
+// size will drop down to medium quality.
+const size_t kMaxHighQualityImageSizeBytes = 64 * 1024 * 1024;
+
+// The number of entries to keep around in the cache. This limit can be breached
+// if more items are locked. That is, locked items ignore this limit.
+const size_t kMaxItemsInCache = 100;
+
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(ImageDecodeController* controller,
-                      const SkImage* image,
-                      int layer_id,
+                      const ImageDecodeController::ImageKey& image_key,
+                      const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
-        image_(skia::SharePtr(image)),
-        layer_id_(layer_id),
+        image_key_(image_key),
+        image_(image),
+        image_ref_(skia::SharePtr(image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "ImageDecodeTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
-        image_.get());
-    controller_->DecodeImage(image_.get());
-
-    // Release the reference after decoding image to ensure that it is not kept
-    // alive unless needed.
-    image_.clear();
+        image_ref_.get());
+    controller_->DecodeImage(image_key_, image_);
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {}
   void CompleteOnOriginThread(TileTaskClient* client) override {
-    controller_->OnImageDecodeTaskCompleted(layer_id_, image_.get(),
-                                            !HasFinishedRunning());
+    controller_->RemovePendingTask(image_key_);
   }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   ImageDecodeController* controller_;
-  skia::RefPtr<const SkImage> image_;
-  int layer_id_;
+  ImageDecodeController::ImageKey image_key_;
+  DrawImage image_;
+  skia::RefPtr<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
+template <typename Type>
+typename std::deque<Type>::iterator FindImage(
+    std::deque<Type>* collection,
+    const ImageDecodeControllerKey& key) {
+  return std::find_if(collection->begin(), collection->end(),
+                      [key](const Type& image) { return image.first == key; });
+}
+
+SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key,
+                          const SkImage* original_image) {
+  float x_scale =
+      key.target_size().width() / static_cast<float>(original_image->width());
+  float y_scale =
+      key.target_size().height() / static_cast<float>(original_image->height());
+  return SkSize::Make(x_scale, y_scale);
+}
+
 }  // namespace
 
-ImageDecodeController::ImageDecodeController() {}
+ImageDecodeController::ImageDecodeController()
+    : is_using_gpu_rasterization_(false),
+      locked_images_budget_(kLockedMemoryLimitBytes) {}
 
 ImageDecodeController::~ImageDecodeController() {}
 
-scoped_refptr<ImageDecodeTask> ImageDecodeController::GetTaskForImage(
+bool ImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& image,
-    int layer_id,
-    uint64_t prepare_tiles_id) {
-  uint32_t generation_id = image.image()->uniqueID();
-  scoped_refptr<ImageDecodeTask>& decode_task =
-      image_decode_tasks_[layer_id][generation_id];
-  if (!decode_task)
-    decode_task = CreateTaskForImage(image.image(), layer_id, prepare_tiles_id);
-  return decode_task;
-}
-
-scoped_refptr<ImageDecodeTask> ImageDecodeController::CreateTaskForImage(
-    const SkImage* image,
-    int layer_id,
-    uint64_t prepare_tiles_id) {
+    uint64_t prepare_tiles_id,
+    scoped_refptr<ImageDecodeTask>* task) {
+  // If the image already exist or if we're going to create a task for it, then

[enne (OOO), 2015/12/02 23:33:25]

exists

[vmpstr, 2015/12/03 21:20:23]

Done.

+  // we need to ref this image. That means the image is or will be in the cache.
+  // When the ref goes to 0, it will be unpinned but will remain in the cache.
+  // If the image does not fit into the budget, then we don't ref this image,
+  // since it will be decoded at raster time which is when it will be
+  // temporarily put in the cache.
+  ImageKey key = ImageKey::FromDrawImage(image);
+  TRACE_EVENT1("cc", "ImageDecodeController::GetTaskForImageAndRef", "key",
+               key.ToString());
+  // If we're not going to do a scale, we will just create a task to preroll the
+  // image the first time we see it. This doesn't need to account for memory.

[enne (OOO), 2015/12/02 23:33:25]

Should we preroll once per frame per image to fix the "first time seen"
nonsense? If it's still in discardable memory, shouldn't it be fast to preroll?
Or, would that be a mistake?

[vmpstr, 2015/12/03 21:20:23]

I don't think that would work for GPU raster, because the image could be in the
uploaded cache (yep, there's more caches to consider!)

The more I think about it, the more it seems difficult to unify software and gpu
paths when it comes to the image decode controller. I think once this has to
manage the uploaded cache too, it will have a nice split into two separate
classes... That's kind of as an aside though.

+  // TODO(vmpstr): We can also lock the original sized image, in which case it
+  // does require memory bookkeeping.
+  if (!ShouldDecodeAndScaleImage(key, image)) {
+    base::AutoLock lock(lock_);
+    if (prerolled_images_.count(key.image_id()) == 0) {
+      scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+      if (!existing_task) {
+        existing_task = make_scoped_refptr(
+            new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
+      }
+      *task = existing_task;
+    } else {
+      *task = nullptr;
+    }
+    return false;
+  }
+
+  base::AutoLock lock(lock_);
+
+  // If we already have the image in cache, then we can return it.
+  auto decoded_it = FindImage(&decoded_images_, key);
+  bool new_image_fits_in_memory =
+      locked_images_budget_.AvailableMemoryBytes() >= key.target_bytes();
+  if (decoded_it != decoded_images_.end()) {
+    if (decoded_it->second->is_locked() ||
+        (new_image_fits_in_memory && decoded_it->second->Lock())) {
+      RefImage(key);
+      *task = nullptr;
+      SanityCheckState(__LINE__, true);
+      return true;
+    }
+    // If the image fits in memory, then we at least tried to lock it and
+    // failed. This means that it's not valid anymore.
+    if (new_image_fits_in_memory)
+      decoded_images_.erase(decoded_it);
+  }
+
+  // If the task exists, return it.
+  scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+  if (existing_task) {
+    RefImage(key);
+    *task = existing_task;
+    SanityCheckState(__LINE__, true);
+    return true;
+  }
+
+  // At this point, we have to create a new image/task, so we need to abort if
+  // it doesn't fit into memory.
+  if (!new_image_fits_in_memory) {
+    *task = nullptr;
+    SanityCheckState(__LINE__, true);
+    return false;
+  }
+
+  // Actually create the image. RefImage will account for memory on the first

[enne (OOO), 2015/12/02 23:33:25]

create the...task?

[vmpstr, 2015/12/03 21:20:23]

Yes. Thanks! Done.

+  // ref, so verify that this is going to be the first ref.
+  DCHECK(decoded_images_ref_counts_.find(key) ==
+         decoded_images_ref_counts_.end());
+
+  RefImage(key);
+  existing_task = make_scoped_refptr(
+      new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
+  *task = existing_task;
+  SanityCheckState(__LINE__, true);
+  return true;
+}
+
+void ImageDecodeController::RefImage(const ImageKey& key) {
+  TRACE_EVENT1("cc", "ImageDecodeController::RefImage", "key", key.ToString());
+  lock_.AssertAcquired();
+  int ref = ++decoded_images_ref_counts_[key];
+  if (ref == 1) {
+    DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.target_bytes());
+    locked_images_budget_.AddUsage(key.target_bytes());
+  }
+}
+
+void ImageDecodeController::UnrefImage(const DrawImage& image) {
+  // When we unref the image, there are several situations we need to consider:
+  // 1. The ref did not reach 0, which means we have to keep the image locked.
+  // 2. The ref reached 0, we should unlock it.
+  //   2a. The image isn't in the locked cache because we didn't get to decode
+  //       it yet.
+  //   2b. Unlock the image but keep it in list.
+  const ImageKey& key = ImageKey::FromDrawImage(image);
+  DCHECK(ShouldDecodeAndScaleImage(key, image));
+  TRACE_EVENT1("cc", "ImageDecodeController::UnrefImage", "key",
+               key.ToString());
+
+  base::AutoLock lock(lock_);
+  auto ref_count_it = decoded_images_ref_counts_.find(key);
+  DCHECK(ref_count_it != decoded_images_ref_counts_.end());
+
+  --ref_count_it->second;
+  if (ref_count_it->second == 0) {
+    decoded_images_ref_counts_.erase(ref_count_it);
+    locked_images_budget_.SubtractUsage(key.target_bytes());
+
+    auto decoded_image_it = FindImage(&decoded_images_, key);
+    // If we've never decoded the image before ref reached 0, then we wouldn't
+    // have it in our cache. This would happen if we canceled tasks.
+    if (decoded_image_it == decoded_images_.end()) {
+      SanityCheckState(__LINE__, true);
+      return;
+    }
+    DCHECK(decoded_image_it->second->is_locked());
+    decoded_image_it->second->Unlock();
+  }
+  SanityCheckState(__LINE__, true);
+}
+
+void ImageDecodeController::DecodeImage(const ImageKey& key,
+                                        const DrawImage& image) {
+  TRACE_EVENT1("cc", "ImageDecodeController::DecodeImage", "key",
+               key.ToString());
+  if (!ShouldDecodeAndScaleImage(key, image)) {
+    image.image()->preroll();
+
+    base::AutoLock lock(lock_);
+    prerolled_images_.insert(key.image_id());
+    // Erase the pending task from the queue, since the task won't be doing
+    // anything useful after this function terminates. Since we don't preroll
+    // images twice, this is actually not necessary but it behaves similar to
+    // the other code path: when this function finishes, the task isn't in the
+    // pending_image_tasks_ list.
+    pending_image_tasks_.erase(key);
+    return;
+  }
+
+  base::AutoLock lock(lock_);
+
+  auto image_it = FindImage(&decoded_images_, key);
+  if (image_it != decoded_images_.end()) {
+    if (image_it->second->is_locked() || image_it->second->Lock()) {
+      pending_image_tasks_.erase(key);
+      return;
+    }
+    decoded_images_.erase(image_it);
+  }
+
+  scoped_refptr<DecodedImage> decoded_image;
+  {
+    base::AutoUnlock unlock(lock_);
+    decoded_image = DecodeImageInternal(key, image.image());
+  }
+
+  // Erase the pending task from the queue, since the task won't be doing
+  // anything useful after this function terminates. That is, if this image
+  // needs to be decoded again, we have to create a new task.
+  pending_image_tasks_.erase(key);
+
+  // We could have finished all of the raster tasks (cancelled) while this image
+  // decode task was running, which means that we now have a locked image but no
+  // ref counts. Unlock it immediately in this case.
+  if (decoded_images_ref_counts_.find(key) ==
+      decoded_images_ref_counts_.end()) {
+    decoded_image->Unlock();
+  }
+
+  // At this point, it could have been the case that this image was decoded in
+  // place by an already running raster task from a previous schedule. If that's
+  // the case, then it would have already been placed into the cache (possibly
+  // locked). Remove it if that was the case.
+  image_it = FindImage(&decoded_images_, key);
+  if (image_it != decoded_images_.end()) {
+    if (image_it->second->is_locked() || image_it->second->Lock()) {
+      pending_image_tasks_.erase(key);
+      return;
+    }
+    decoded_images_.erase(image_it);
+  }
+  decoded_images_.push_back(AnnotatedDecodedImage(key, decoded_image));
+  SanityCheckState(__LINE__, true);
+}
+
+scoped_refptr<ImageDecodeController::DecodedImage>
+ImageDecodeController::DecodeImageInternal(const ImageKey& key,
+                                           const SkImage* image) {
+  TRACE_EVENT1("cc", "ImageDecodeController::DecodeImageInternal", "key",
+               key.ToString());
+
+  // Get the decoded image first (at the original scale).
+  SkImageInfo decoded_info =
+      SkImageInfo::MakeN32Premul(image->width(), image->height());
+  scoped_ptr<uint8_t[]> decoded_pixels(
+      new uint8_t[decoded_info.minRowBytes() * decoded_info.height()]);
+  bool result = image->readPixels(decoded_info, decoded_pixels.get(),
+                                  decoded_info.minRowBytes(), 0, 0,
+                                  SkImage::kAllow_CachingHint);
+  DCHECK(result);
+
+  skia::RefPtr<SkImage> decoded_image = skia::AdoptRef(SkImage::NewFromRaster(
+      decoded_info, decoded_pixels.get(), decoded_info.minRowBytes(),
+      [](const void* pixels, void* context) {}, nullptr));
+
+  // Now scale the pixels into the destination size.
+  SkImageInfo scaled_info = SkImageInfo::MakeN32Premul(
+      key.target_size().width(), key.target_size().height());
+  scoped_ptr<base::DiscardableMemory> scaled_pixels =
+      base::DiscardableMemoryAllocator::GetInstance()
+          ->AllocateLockedDiscardableMemory(scaled_info.minRowBytes() *
+                                            scaled_info.height());
+  SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
+                         scaled_info.minRowBytes());
+  // TODO(vmpstr): Start handling more than just high filter quality.
+  DCHECK_EQ(kHigh_SkFilterQuality, key.filter_quality());
+  result = decoded_image->scalePixels(scaled_pixmap, kHigh_SkFilterQuality,
+                                      SkImage::kDisallow_CachingHint);
+  DCHECK(result);
   return make_scoped_refptr(
-      new ImageDecodeTaskImpl(this, image, layer_id, prepare_tiles_id));
-}
-
-void ImageDecodeController::DecodeImage(const SkImage* image) {
-  image->preroll();
-}
-
-void ImageDecodeController::AddLayerUsedCount(int layer_id) {
-  ++used_layer_counts_[layer_id];
-}
-
-void ImageDecodeController::SubtractLayerUsedCount(int layer_id) {
-  if (--used_layer_counts_[layer_id])
+      new DecodedImage(scaled_info, std::move(scaled_pixels)));
+}
+
+DecodedDrawImage ImageDecodeController::GetDecodedImageForDraw(
+    const DrawImage& draw_image) {
+  ImageKey key = ImageKey::FromDrawImage(draw_image);
+  TRACE_EVENT1("cc", "ImageDecodeController::GetDecodedImageAndRef", "key",
+               key.ToString());
+  if (!ShouldDecodeAndScaleImage(key, draw_image)) {
+    return DecodedDrawImage(draw_image.image(), SkSize::Make(1.f, 1.f),
+                            draw_image.filter_quality());
+  }
+
+  base::AutoLock lock(lock_);
+  auto decoded_images_it = FindImage(&decoded_images_, key);
+  // If we found the image and it's locked, then return it. If it's not locked,
+  // erase it from the cache since it might be put into the at-raster cache.
+  scoped_refptr<DecodedImage> decoded_image;
+  if (decoded_images_it != decoded_images_.end()) {
+    decoded_image = decoded_images_it->second;
+    if (decoded_image->is_locked()) {
+      RefImage(key);
+      SanityCheckState(__LINE__, true);
+      return DecodedDrawImage(decoded_image->image(),
+                              GetScaleAdjustment(key, draw_image.image()),
+                              kLow_SkFilterQuality);
+    } else {
+      decoded_images_.erase(decoded_images_it);
+    }
+  }
+
+  // See if another thread already decoded this image at raster time. If so, we
+  // can just use that result directly.
+  auto at_raster_images_it = FindImage(&at_raster_decoded_images_, key);
+  if (at_raster_images_it != at_raster_decoded_images_.end()) {
+    DCHECK(at_raster_images_it->second->is_locked());
+    RefAtRasterImage(key);
+    SanityCheckState(__LINE__, true);
+    auto decoded_draw_image = DecodedDrawImage(
+        at_raster_images_it->second->image(),
+        GetScaleAdjustment(key, draw_image.image()), kLow_SkFilterQuality);
+    decoded_draw_image.set_at_raster_decode(true);
+    return decoded_draw_image;
+  }
+
+  // Now we know that we don't have a locked image, and we seem to be the first
+  // thread encountering this image (that might not be true, since other threads
+  // might be decoding it already). This means that we need to decode the image
+  // assuming we can't lock the one we found in the cache.
+  bool check_at_raster_cache = false;
+  if (!decoded_image || !decoded_image->Lock()) {
+    // Note that we have to release the lock, since this lock is also accessed
+    // on the compositor thread. This means holding on to the lock might stall
+    // the compositor thread for the duration of the decode!
+    base::AutoUnlock unlock(lock_);
+    decoded_image = DecodeImageInternal(key, draw_image.image());
+    check_at_raster_cache = true;
+  }
+
+  // While we unlocked the lock, it could be the case that another thread
+  // already decoded this already and put it in the at-raster cache. Look it up
+  // first.
+  bool need_to_add_image_to_cache = true;
+  if (check_at_raster_cache) {
+    at_raster_images_it = FindImage(&at_raster_decoded_images_, key);
+    if (at_raster_images_it != at_raster_decoded_images_.end()) {
+      // We have to drop our decode, since the one in the cache is being used by
+      // another thread.
+      decoded_image->Unlock();
+      decoded_image = at_raster_images_it->second;
+      need_to_add_image_to_cache = false;
+    }
+  }
+
+  // If we really are the first ones, or if the other thread already unlocked
+  // the image, then put our work into at-raster time cache.
+  if (need_to_add_image_to_cache) {
+    at_raster_decoded_images_.push_back(
+        AnnotatedDecodedImage(key, decoded_image));
+  }
+
+  DCHECK(decoded_image);
+  DCHECK(decoded_image->is_locked());
+  RefAtRasterImage(key);
+  SanityCheckState(__LINE__, true);
+  auto decoded_draw_image = DecodedDrawImage(
+      decoded_image->image(), GetScaleAdjustment(key, draw_image.image()),
+      kLow_SkFilterQuality);
+  decoded_draw_image.set_at_raster_decode(true);
+  return decoded_draw_image;
+}
+
+void ImageDecodeController::DrawWithImageFinished(
+    const DrawImage& image,
+    const DecodedDrawImage& decoded_image) {
+  TRACE_EVENT1("cc", "ImageDecodeController::DrawWithImageFinished", "key",
+               ImageKey::FromDrawImage(image).ToString());
+  ImageKey key = ImageKey::FromDrawImage(image);
+  if (!ShouldDecodeAndScaleImage(key, image))
     return;
 
-  // Clean up decode tasks once a layer is no longer used.
-  used_layer_counts_.erase(layer_id);
-  image_decode_tasks_.erase(layer_id);
-}
-
-void ImageDecodeController::OnImageDecodeTaskCompleted(int layer_id,
-                                                       const SkImage* image,
-                                                       bool was_canceled) {
-  // If the task has successfully finished, then keep the task until the layer
-  // is no longer in use. This ensures that we only decode a image once.
-  // TODO(vmpstr): Remove this when decode lifetime is controlled by cc.
-  if (!was_canceled)
+  if (decoded_image.is_at_raster_decode())
+    UnrefAtRasterImage(key);
+  else
+    UnrefImage(image);
+  SanityCheckState(__LINE__, false);
+}
+
+void ImageDecodeController::RefAtRasterImage(const ImageKey& key) {
+  TRACE_EVENT1("cc", "ImageDecodeController::RefAtRasterImage", "key",
+               key.ToString());
+  DCHECK(FindImage(&at_raster_decoded_images_, key) !=
+         at_raster_decoded_images_.end());
+  ++at_raster_decoded_images_ref_counts_[key];
+}
+
+void ImageDecodeController::UnrefAtRasterImage(const ImageKey& key) {
+  TRACE_EVENT1("cc", "ImageDecodeController::UnrefAtRasterImage", "key",
+               key.ToString());
+  base::AutoLock lock(lock_);
+
+  auto ref_it = at_raster_decoded_images_ref_counts_.find(key);
+  DCHECK(ref_it != at_raster_decoded_images_ref_counts_.end());
+  --ref_it->second;
+  if (ref_it->second == 0) {
+    at_raster_decoded_images_ref_counts_.erase(ref_it);
+    auto at_raster_image_it = FindImage(&at_raster_decoded_images_, key);
+    DCHECK(at_raster_image_it != at_raster_decoded_images_.end());
+
+    // The ref for our image reached 0 and it's still locked. We need to figure
+    // out what the best thing to do with the image. There are several
+    // situations:
+    // 1. The image is not in the main cache and...
+    //    1a. ... its ref count is 0: unlock our image and put it in the main
+    //    cache.
+    //    1b. ... ref count is not 0: keep the image locked and put it in the
+    //    main cache.
+    // 2. The image is in the main cache...
+    //    2a. ... and is locked: unlock our image and discard it
+    //    2b. ... and is unlocked and...
+    //       2b1. ... its ref count is 0: unlock our image and replace the
+    //       existing one with ours.
+    //       2b2. ... its ref count is not 0: keep our image locked and replace

[enne (OOO), 2015/12/02 23:33:25]

Anything that gets into 2b2 outline form scares me a tiny bit.  Is there any way
to unit test all the unlocking scenarios?

[vmpstr, 2015/12/03 21:20:23]

I've added a bunch of tests that I think cover all of the points. And yes, I
think 2b2 isn't possible, I've changed the comment and added a DCHECK instead of
the if. 

+    //       the existing one with ours.
+    auto image_it = FindImage(&decoded_images_, key);
+    if (image_it == decoded_images_.end()) {
+      if (decoded_images_ref_counts_.find(key) ==
+          decoded_images_ref_counts_.end()) {
+        at_raster_image_it->second->Unlock();
+      }
+      decoded_images_.push_back(*at_raster_image_it);
+    } else if (image_it->second->is_locked()) {
+      at_raster_image_it->second->Unlock();
+    } else {
+      if (decoded_images_ref_counts_.find(key) ==
+          decoded_images_ref_counts_.end()) {
+        at_raster_image_it->second->Unlock();
+      }
+      decoded_images_.erase(image_it);
+      decoded_images_.push_back(*at_raster_image_it);
+    }
+    at_raster_decoded_images_.erase(at_raster_image_it);
+  }
+}
+
+bool ImageDecodeController::ShouldDecodeAndScaleImage(const ImageKey& key,
+                                                      const DrawImage& image) {
+  // TODO(vmpstr): Handle GPU rasterization.
+  if (is_using_gpu_rasterization_)
+    return false;
+
+  if (!CanHandleFilterQuality(key.filter_quality()))
+    return false;
+
+  // TODO(vmpstr): When we can lock SkImages directly, this condition should be
+  // modified. However, note that code needs to be added elsewhere to special
+  // case this.
+  if (key.target_size().width() == image.image()->width() &&
+      key.target_size().height() == image.image()->height()) {
+    return false;
+  }
+  return true;
+}
+
+bool ImageDecodeController::CanHandleFilterQuality(
+    SkFilterQuality filter_quality) {
+  // We don't need to handle low quality filters.
+  if (filter_quality == kLow_SkFilterQuality ||
+      filter_quality == kNone_SkFilterQuality) {
+    return false;
+  }
+
+  // TODO(vmpstr): We need to start caching mipmaps for medium quality and
+  // caching the interpolated values from those. For now, we don't have this.
+  if (filter_quality == kMedium_SkFilterQuality)
+    return false;
+  DCHECK(filter_quality == kHigh_SkFilterQuality);
+  return true;
+}
+
+void ImageDecodeController::ReduceCacheUsage() {
+  TRACE_EVENT0("cc", "ImageDecodeController::ReduceCacheUsage");
+  base::AutoLock lock(lock_);
+  size_t num_to_remove = (decoded_images_.size() > kMaxItemsInCache)
+                             ? (decoded_images_.size() - kMaxItemsInCache)
+                             : 0;
+  for (auto it = decoded_images_.begin();
+       num_to_remove != 0 && it != decoded_images_.end();) {
+    if (it->second->is_locked()) {
+      ++it;
+      continue;
+    }
+
+    it = decoded_images_.erase(it);
+    --num_to_remove;
+  }
+}
+
+void ImageDecodeController::RemovePendingTask(const ImageKey& key) {
+  base::AutoLock lock(lock_);
+  pending_image_tasks_.erase(key);
+}
+
+void ImageDecodeController::SetIsUsingGpuRasterization(
+    bool is_using_gpu_rasterization) {
+  if (is_using_gpu_rasterization_ == is_using_gpu_rasterization)
     return;
-
-  // Otherwise, we have to clean up the task so that a new one can be created if
-  // we need to decode the image again.
-  LayerImageTaskMap::iterator layer_it = image_decode_tasks_.find(layer_id);
-  if (layer_it == image_decode_tasks_.end())
-    return;
-
-  ImageTaskMap& image_tasks = layer_it->second;
-  ImageTaskMap::iterator task_it = image_tasks.find(image->uniqueID());
-  if (task_it == image_tasks.end())
-    return;
-  image_tasks.erase(task_it);
+  is_using_gpu_rasterization_ = is_using_gpu_rasterization;
+
+  base::AutoLock lock(lock_);
+
+  DCHECK_EQ(0u, decoded_images_ref_counts_.size());

[enne (OOO), 2015/12/02 23:33:25]

This is a lot of surprising checks in a setter function.  Can you summarize this
in the header about when this function is safe to call?

[vmpstr, 2015/12/03 21:20:23]

Done.

+  DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
+  DCHECK(std::find_if(decoded_images_.begin(), decoded_images_.end(),
+                      [](const AnnotatedDecodedImage& image) {
+                        return image.second->is_locked();
+                      }) == decoded_images_.end());
+  DCHECK(std::find_if(at_raster_decoded_images_.begin(),
+                      at_raster_decoded_images_.end(),
+                      [](const AnnotatedDecodedImage& image) {
+                        return image.second->is_locked();
+                      }) == at_raster_decoded_images_.end());
+  decoded_images_.clear();
+  at_raster_decoded_images_.clear();
+}
+
+size_t ImageDecodeController::SanityCheckState(int line, bool lock_acquired) {
+#if DCHECK_IS_ON()
+  if (!lock_acquired) {
+    base::AutoLock lock(lock_);
+    return SanityCheckState(line, true);
+  }
+
+  MemoryBudget budget(kLockedMemoryLimitBytes);
+  for (const auto& annotated_image : decoded_images_) {
+    auto ref_it = decoded_images_ref_counts_.find(annotated_image.first);
+    if (annotated_image.second->is_locked()) {
+      budget.AddUsage(annotated_image.first.target_bytes());
+      DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
+    } else {
+      DCHECK(ref_it == decoded_images_ref_counts_.end() ||
+             pending_image_tasks_.find(annotated_image.first) !=
+                 pending_image_tasks_.end())
+          << line;
+    }
+  }
+  DCHECK_GE(budget.AvailableMemoryBytes(),
+            locked_images_budget_.AvailableMemoryBytes())
+      << line;
+  return budget.AvailableMemoryBytes();
+#else
+  return 0u;
+#endif  // DCHECK_IS_ON()
+}
+
+static bool ScaleIsNearlyIdentity(const SkSize& scale) {
+  return std::abs(scale.width() - 1.f) < FLT_EPSILON &&
+         std::abs(scale.height() - 1.f) < FLT_EPSILON;
+}
+
+// ImageDecodeControllerKey
+ImageDecodeControllerKey ImageDecodeControllerKey::FromDrawImage(
+    const DrawImage& image) {
+  SkSize scale = image.scale();
+  SkFilterQuality quality = image.filter_quality();
+  if (ScaleIsNearlyIdentity(scale)) {
+    scale.set(1.f, 1.f);
+    quality = kLow_SkFilterQuality;
+  }
+
+  gfx::Size target_size(
+      std::abs(SkScalarRoundToInt(image.image()->width() * scale.width())),
+      std::abs(SkScalarRoundToInt(image.image()->height() * scale.height())));
+
+  if (quality == kHigh_SkFilterQuality) {
+    if (image.matrix_has_perspective() || !image.matrix_is_decomposable()) {
+      quality = kMedium_SkFilterQuality;
+    } else {
+      base::CheckedNumeric<size_t> size = 4;
+      size *= target_size.width();
+      size *= target_size.height();
+      if (size.ValueOrDefault(std::numeric_limits<size_t>::max()) >
+          kMaxHighQualityImageSizeBytes) {
+        quality = kMedium_SkFilterQuality;
+      }
+    }
+  }
+
+  if (quality == kMedium_SkFilterQuality) {
+    if (!image.matrix_is_decomposable() ||
+        (scale.width() >= 1.f && scale.height() >= 1.f)) {
+      quality = kLow_SkFilterQuality;
+    }
+  }
+
+  return ImageDecodeControllerKey(image.image()->uniqueID(), target_size,
+                                  quality);
+}
+
+ImageDecodeControllerKey::ImageDecodeControllerKey(
+    uint32_t image_id,
+    const gfx::Size& size,
+    SkFilterQuality filter_quality)
+    : image_id_(image_id), size_(size), filter_quality_(filter_quality) {}
+
+std::string ImageDecodeControllerKey::ToString() const {
+  std::ostringstream str;
+  str << "id[" << image_id_ << "] size[" << size_.width() << "x"
+      << size_.height() << "] filter_quality[" << filter_quality_ << "]";
+  return str.str();
+}
+
+// DecodedImage
+ImageDecodeController::DecodedImage::DecodedImage(
+    const SkImageInfo& info,
+    scoped_ptr<base::DiscardableMemory> memory)
+    : locked_(true), image_info_(info), memory_(memory.Pass()) {
+  image_ = skia::AdoptRef(SkImage::NewFromRaster(
+      image_info_, memory_->data(), image_info_.minRowBytes(),
+      [](const void* pixels, void* context) {}, nullptr));
+}
+
+ImageDecodeController::DecodedImage::~DecodedImage() {}
+
+bool ImageDecodeController::DecodedImage::Lock() {
+  DCHECK(!locked_);
+  bool success = memory_->Lock();
+  if (!success)
+    return false;
+  locked_ = true;
+  return true;
+}
+
+void ImageDecodeController::DecodedImage::Unlock() {
+  DCHECK(locked_);
+  memory_->Unlock();
+  locked_ = false;
+}
+
+// MemoryBudget
+ImageDecodeController::MemoryBudget::MemoryBudget(size_t limit_bytes)
+    : limit_bytes_(limit_bytes), current_usage_bytes_(0u) {}
+
+size_t ImageDecodeController::MemoryBudget::AvailableMemoryBytes() const {
+  size_t usage = GetCurrentUsageSafe();
+  return usage >= limit_bytes_ ? 0u : (limit_bytes_ - usage);
+}
+
+void ImageDecodeController::MemoryBudget::AddUsage(size_t usage) {
+  current_usage_bytes_ += usage;
+}
+
+void ImageDecodeController::MemoryBudget::SubtractUsage(size_t usage) {
+  DCHECK_GE(current_usage_bytes_.ValueOrDefault(0u), usage);
+  current_usage_bytes_ -= usage;
+}
+
+void ImageDecodeController::MemoryBudget::ResetUsage() {
+  current_usage_bytes_ = 0;
+}
+
+size_t ImageDecodeController::MemoryBudget::GetCurrentUsageSafe() const {
+  return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc