cc: Rename ImageDecodeController to ImageDecodeCache.

This patch renames ImageDecodeController to ImageDecodeCache, along
with software and gpu implementations.

R=enne@chromium.org, ericrk@chromium.org
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel

Review-Url: https://codereview.chromium.org/2541183002
Cr-Commit-Position: refs/heads/master@{#435530}

cc/BUILD.gn

@@ -425,9 +425,9 @@ cc_component("cc") {
     "scheduler/video_frame_controller.h",
     "tiles/eviction_tile_priority_queue.cc",
     "tiles/eviction_tile_priority_queue.h",
-    "tiles/gpu_image_decode_controller.cc",
-    "tiles/gpu_image_decode_controller.h",
-    "tiles/image_decode_controller.h",
+    "tiles/gpu_image_decode_cache.cc",
+    "tiles/gpu_image_decode_cache.h",
+    "tiles/image_decode_cache.h",
     "tiles/image_manager.cc",
     "tiles/image_manager.h",
     "tiles/mipmap_util.cc",
@@ -444,8 +444,8 @@ cc_component("cc") {
     "tiles/raster_tile_priority_queue_all.h",
     "tiles/raster_tile_priority_queue_required.cc",
     "tiles/raster_tile_priority_queue_required.h",
-    "tiles/software_image_decode_controller.cc",
-    "tiles/software_image_decode_controller.h",
+    "tiles/software_image_decode_cache.cc",
+    "tiles/software_image_decode_cache.h",
     "tiles/tile.cc",
     "tiles/tile.h",
     "tiles/tile_draw_info.cc",
@@ -883,12 +883,12 @@ cc_test("cc_unittests") {
     "test/mock_helper_unittest.cc",
     "test/ordered_simple_task_runner_unittest.cc",
     "test/test_web_graphics_context_3d_unittest.cc",
-    "tiles/gpu_image_decode_controller_unittest.cc",
+    "tiles/gpu_image_decode_cache_unittest.cc",
     "tiles/image_manager_unittest.cc",
     "tiles/mipmap_util_unittest.cc",
     "tiles/picture_layer_tiling_set_unittest.cc",
     "tiles/picture_layer_tiling_unittest.cc",
-    "tiles/software_image_decode_controller_unittest.cc",
+    "tiles/software_image_decode_cache_unittest.cc",
     "tiles/tile_manager_unittest.cc",
     "tiles/tile_priority_unittest.cc",
     "trees/blocking_task_runner_unittest.cc",

cc/layers/picture_layer_impl.cc

@@ -577,8 +577,8 @@ void PictureLayerImpl::UpdateRasterSource(
 
   // Only set the image decode controller when we're committing.
   if (!pending_set) {
-    raster_source_->set_image_decode_controller(
-        layer_tree_impl()->image_decode_controller());
+    raster_source_->set_image_decode_cache(
+        layer_tree_impl()->image_decode_cache());
   }
 
   // The |new_invalidation| must be cleared before updating tilings since they
@@ -679,8 +679,8 @@ void PictureLayerImpl::ReleaseTileResources() {
 void PictureLayerImpl::RecreateTileResources() {
   tilings_ = CreatePictureLayerTilingSet();
   if (raster_source_) {
-    raster_source_->set_image_decode_controller(
-        layer_tree_impl()->image_decode_controller());
+    raster_source_->set_image_decode_cache(
+        layer_tree_impl()->image_decode_cache());
   }
 }
 

cc/output/software_renderer.cc

@@ -339,10 +339,10 @@ void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
   playback_settings.playback_to_shared_canvas = true;
   // Indicates whether content rasterization should happen through an
   // ImageHijackCanvas, which causes image decodes to be managed by an
-  // ImageDecodeController. PictureDrawQuads are used for resourceless software
-  // draws, while a GPU ImageDecodeController may be in use by the compositor
+  // ImageDecodeCache. PictureDrawQuads are used for resourceless software
+  // draws, while a GPU ImageDecodeCache may be in use by the compositor
   // providing the RasterSource. So we disable the image hijack canvas to avoid
-  // trying to use the GPU ImageDecodeController while doing a software draw.
+  // trying to use the GPU ImageDecodeCache while doing a software draw.
   playback_settings.use_image_hijack_canvas = false;
   if (needs_transparency || disable_image_filtering) {
     // TODO(aelias): This isn't correct in all cases. We should detect these

cc/playback/image_hijack_canvas.cc

@@ -6,7 +6,7 @@
 
 #include "base/optional.h"
 #include "cc/playback/discardable_image_map.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
 
 namespace cc {
 namespace {
@@ -19,18 +19,18 @@ SkIRect RoundOutRect(const SkRect& rect) {
 
 class ScopedDecodedImageLock {
  public:
-  ScopedDecodedImageLock(ImageDecodeController* image_decode_controller,
+  ScopedDecodedImageLock(ImageDecodeCache* image_decode_cache,
                          sk_sp<const SkImage> image,
                          const SkRect& src_rect,
                          const SkMatrix& matrix,
                          const SkPaint* paint)
-      : image_decode_controller_(image_decode_controller),
+      : image_decode_cache_(image_decode_cache),
         draw_image_(std::move(image),
                     RoundOutRect(src_rect),
                     paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
                     matrix),
         decoded_draw_image_(
-            image_decode_controller_->GetDecodedImageForDraw(draw_image_)) {
+            image_decode_cache_->GetDecodedImageForDraw(draw_image_)) {
     DCHECK(draw_image_.image()->isLazyGenerated());
     if (paint) {
       decoded_paint_ = *paint;
@@ -39,8 +39,8 @@ class ScopedDecodedImageLock {
   }
 
   ~ScopedDecodedImageLock() {
-    image_decode_controller_->DrawWithImageFinished(draw_image_,
-                                                    decoded_draw_image_);
+    image_decode_cache_->DrawWithImageFinished(draw_image_,
+                                               decoded_draw_image_);
   }
 
   const DecodedDrawImage& decoded_image() const { return decoded_draw_image_; }
@@ -49,20 +49,18 @@ class ScopedDecodedImageLock {
   }
 
  private:
-  ImageDecodeController* image_decode_controller_;
+  ImageDecodeCache* image_decode_cache_;
   DrawImage draw_image_;
   DecodedDrawImage decoded_draw_image_;
   base::Optional<SkPaint> decoded_paint_;
 };
 
 }  // namespace
 
-ImageHijackCanvas::ImageHijackCanvas(
-    int width,
-    int height,
-    ImageDecodeController* image_decode_controller)
-    : SkNWayCanvas(width, height),
-      image_decode_controller_(image_decode_controller) {}
+ImageHijackCanvas::ImageHijackCanvas(int width,
+                                     int height,
+                                     ImageDecodeCache* image_decode_cache)
+    : SkNWayCanvas(width, height), image_decode_cache_(image_decode_cache) {}
 
 void ImageHijackCanvas::onDrawPicture(const SkPicture* picture,
                                       const SkMatrix* matrix,
@@ -84,7 +82,7 @@ void ImageHijackCanvas::onDrawImage(const SkImage* image,
   SkMatrix ctm = getTotalMatrix();
 
   ScopedDecodedImageLock scoped_lock(
-      image_decode_controller_, sk_ref_sp(image),
+      image_decode_cache_, sk_ref_sp(image),
       SkRect::MakeIWH(image->width(), image->height()), ctm, paint);
   const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
   if (!decoded_image.image())
@@ -124,7 +122,7 @@ void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
   matrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
   matrix.postConcat(getTotalMatrix());
 
-  ScopedDecodedImageLock scoped_lock(image_decode_controller_, sk_ref_sp(image),
+  ScopedDecodedImageLock scoped_lock(image_decode_cache_, sk_ref_sp(image),
                                      *src, matrix, paint);
   const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
   if (!decoded_image.image())

cc/playback/image_hijack_canvas.h

@@ -10,13 +10,13 @@
 
 namespace cc {
 
-class ImageDecodeController;
+class ImageDecodeCache;
 
 class ImageHijackCanvas : public SkNWayCanvas {
  public:
   ImageHijackCanvas(int width,
                     int height,
-                    ImageDecodeController* image_decode_controller);
+                    ImageDecodeCache* image_decode_cache);
 
  private:
   // Ensure that pictures are unpacked by this canvas, instead of being
@@ -39,7 +39,7 @@ class ImageHijackCanvas : public SkNWayCanvas {
                        const SkRect& dst,
                        const SkPaint* paint) override;
 
-  ImageDecodeController* image_decode_controller_;
+  ImageDecodeCache* image_decode_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageHijackCanvas);
 };

cc/playback/raster_source.cc

@@ -41,7 +41,7 @@ RasterSource::RasterSource(const RecordingSource* other, bool can_use_lcd_text)
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(false),
-      image_decode_controller_(nullptr) {}
+      image_decode_cache_(nullptr) {}
 
 RasterSource::RasterSource(const RasterSource* other, bool can_use_lcd_text)
     : display_list_(other->display_list_),
@@ -58,8 +58,7 @@ RasterSource::RasterSource(const RasterSource* other, bool can_use_lcd_text)
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(
           other->should_attempt_to_use_distance_field_text_),
-      image_decode_controller_(other->image_decode_controller_) {
-}
+      image_decode_cache_(other->image_decode_cache_) {}
 
 RasterSource::~RasterSource() {
 }
@@ -95,8 +94,7 @@ void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas,
   } else if (settings.use_image_hijack_canvas) {
     const SkImageInfo& info = raster_canvas->imageInfo();
 
-    ImageHijackCanvas canvas(info.width(), info.height(),
-                             image_decode_controller_);
+    ImageHijackCanvas canvas(info.width(), info.height(), image_decode_cache_);
     // Before adding the canvas, make sure that the ImageHijackCanvas is aware
     // of the current transform and clip, which may affect the clip bounds.
     // Since we query the clip bounds of the current canvas to get the list of

cc/playback/raster_source.h

@@ -24,7 +24,7 @@ class ColorSpace;
 namespace cc {
 class DisplayItemList;
 class DrawImage;
-class ImageDecodeController;
+class ImageDecodeCache;
 
 class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
  public:
@@ -128,22 +128,19 @@ class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
 
   // Image decode controller should be set once. Its lifetime has to exceed that
   // of the raster source, since the raster source will access it during raster.
-  void set_image_decode_controller(
-      ImageDecodeController* image_decode_controller) {
-    DCHECK(image_decode_controller);
-    image_decode_controller_ = image_decode_controller;
+  void set_image_decode_cache(ImageDecodeCache* image_decode_cache) {
+    DCHECK(image_decode_cache);
+    image_decode_cache_ = image_decode_cache;
   }
 
-  // Returns the ImageDecodeController, currently only used by
+  // Returns the ImageDecodeCache, currently only used by
   // GpuRasterBufferProvider in order to create its own ImageHijackCanvas.
   // Because of the MultiPictureDraw approach used by GPU raster, it does not
   // integrate well with the use of the ImageHijackCanvas internal to this
   // class. See gpu_raster_buffer_provider.cc for more information.
   // TODO(crbug.com/628394): Redesign this to avoid exposing
-  // ImageDecodeController from the raster source.
-  ImageDecodeController* image_decode_controller() const {
-    return image_decode_controller_;
-  }
+  // ImageDecodeCache from the raster source.
+  ImageDecodeCache* image_decode_cache() const { return image_decode_cache_; }
 
  protected:
   friend class base::RefCountedThreadSafe<RasterSource>;
@@ -171,7 +168,7 @@ class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
 
   // In practice, this is only set once before raster begins, so it's ok with
   // respect to threading.
-  ImageDecodeController* image_decode_controller_;
+  ImageDecodeCache* image_decode_cache_;
 
  private:
   void RasterCommon(SkCanvas* canvas, SkPicture::AbortCallback* callback) const;

cc/playback/raster_source_unittest.cc

@@ -10,7 +10,7 @@
 
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
@@ -581,10 +581,10 @@ TEST(RasterSourceTest, ImageHijackCanvasRespectsSharedCanvasTransform) {
   bool can_use_lcd = true;
   scoped_refptr<RasterSource> raster_source =
       recording_source->CreateRasterSource(can_use_lcd);
-  SoftwareImageDecodeController controller(
+  SoftwareImageDecodeCache controller(
       ResourceFormat::RGBA_8888,
       LayerTreeSettings().software_decoded_image_budget_bytes);
-  raster_source->set_image_decode_controller(&controller);
+  raster_source->set_image_decode_cache(&controller);
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(size.width() * 0.5f, size.height() * 0.25f);

cc/raster/gpu_raster_buffer_provider.cc

@@ -87,7 +87,7 @@ static void RasterizePicture(SkPicture* picture,
                              bool can_use_lcd_text,
                              bool ignore_resource_color_space,
                              int msaa_sample_count,
-                             ImageDecodeController* image_decode_controller,
+                             ImageDecodeCache* image_decode_cache,
                              bool use_image_hijack_canvas) {
   ScopedGpuRaster gpu_raster(context_provider);
 
@@ -106,10 +106,10 @@ static void RasterizePicture(SkPicture* picture,
   SkCanvas* canvas = sk_surface->getCanvas();
   std::unique_ptr<ImageHijackCanvas> hijack_canvas;
   if (use_image_hijack_canvas) {
-    DCHECK(image_decode_controller);
+    DCHECK(image_decode_cache);
     const SkImageInfo& info = canvas->imageInfo();
-    hijack_canvas.reset(new ImageHijackCanvas(info.width(), info.height(),
-                                              image_decode_controller));
+    hijack_canvas.reset(
+        new ImageHijackCanvas(info.width(), info.height(), image_decode_cache));
     SkIRect raster_bounds;
     canvas->getClipDeviceBounds(&raster_bounds);
     hijack_canvas->clipRect(SkRect::MakeFromIRect(raster_bounds));
@@ -274,7 +274,7 @@ void GpuRasterBufferProvider::PlaybackOnWorkerThread(
                    async_worker_context_enabled_, use_distance_field_text,
                    raster_source->CanUseLCDText(),
                    raster_source->HasImpliedColorSpace(), msaa_sample_count_,
-                   raster_source->image_decode_controller(),
+                   raster_source->image_decode_cache(),
                    playback_settings.use_image_hijack_canvas);
 
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();

cc/test/fake_tile_manager.cc

@@ -34,14 +34,13 @@ FakeTileManager::FakeTileManager(TileManagerClient* client)
                   base::ThreadTaskRunnerHandle::Get().get(),
                   std::numeric_limits<size_t>::max(),
                   false /* use_partial_raster */),
-      image_decode_controller_(
+      image_decode_cache_(
           ResourceFormat::RGBA_8888,
           LayerTreeSettings().software_decoded_image_budget_bytes) {
-  SetResources(nullptr, &image_decode_controller_,
-               g_synchronous_task_graph_runner.Pointer(),
-               g_fake_raster_buffer_provider.Pointer(),
-               std::numeric_limits<size_t>::max(),
-               false /* use_gpu_rasterization */);
+  SetResources(
+      nullptr, &image_decode_cache_, g_synchronous_task_graph_runner.Pointer(),
+      g_fake_raster_buffer_provider.Pointer(),
+      std::numeric_limits<size_t>::max(), false /* use_gpu_rasterization */);
   SetTileTaskManagerForTesting(base::MakeUnique<FakeTileTaskManagerImpl>());
 }
 
@@ -51,10 +50,10 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
                   base::ThreadTaskRunnerHandle::Get().get(),
                   std::numeric_limits<size_t>::max(),
                   false /* use_partial_raster */),
-      image_decode_controller_(
+      image_decode_cache_(
           ResourceFormat::RGBA_8888,
           LayerTreeSettings().software_decoded_image_budget_bytes) {
-  SetResources(resource_pool, &image_decode_controller_,
+  SetResources(resource_pool, &image_decode_cache_,
                g_synchronous_task_graph_runner.Pointer(),
                g_fake_raster_buffer_provider.Pointer(),
                std::numeric_limits<size_t>::max(),

cc/test/fake_tile_manager.h

@@ -8,7 +8,7 @@
 #include <set>
 #include <vector>
 
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
 #include "cc/tiles/tile_manager.h"
 
 namespace cc {
@@ -28,7 +28,7 @@ class FakeTileManager : public TileManager {
   std::vector<Tile*> tiles_for_raster;
 
  private:
-  SoftwareImageDecodeController image_decode_controller_;
+  SoftwareImageDecodeCache image_decode_cache_;
 };
 
 }  // namespace cc