Implement remaining SkBitmapOperations as ImageSkiaOperations

ui/gfx/image/image_skia_operations.cc

 // Copyright (c) 2012 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 "ui/gfx/image/image_skia_operations.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 71 matching lines @@
     const Size target_pixel_size(target_size_in_dip_.Scale(scale));
     const SkBitmap resized = skia::ImageOperations::Resize(
         image_rep.sk_bitmap(),
         skia::ImageOperations::RESIZE_BEST,
         target_pixel_size.width(),
         target_pixel_size.height());
     return ImageSkiaRep(resized, image_rep.scale_factor());
  }
 
 private:
  const ImageSkia source_;

[sky, 2012/07/16 20:56:10]

All of these classes roughly follow the same pattern. They cache and existing
ImageSkia and do some operation on it. This results in double the images (since
we effectively never release the source_). Is there some way to release the
source when we know its not needed anymore?

[oshima, 2012/07/16 21:08:35]

My plan is to make ScaleFactor an object which contains the active scale
factors,
and clears the cached images for inactive scale factors.
 This should be able to address most of your concern. Downside is that there
will be several
images that won't be cleared, but I believe this is better than adding observer
to or
have complete list of all instance of ImageSkia.

  const Size target_size_in_dip_;
 
  DISALLOW_COPY_AND_ASSIGN(ResizingImageSource);
 };
 
 class BlendingImageSource : public gfx::ImageSkiaSource {
  public:
   BlendingImageSource(const ImageSkia& first,
                       const ImageSkia& second,
                       double alpha)
       : first_(first),
         second_(second),
         alpha_(alpha) {
   }
 
+  virtual ~BlendingImageSource() {
+  }
+
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep first_rep = first_.GetRepresentation(scale_factor);
     ImageSkiaRep second_rep = second_.GetRepresentation(scale_factor);
     MatchScale(&first_rep, &second_rep);
     SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
         first_rep.sk_bitmap(), second_rep.sk_bitmap(), alpha_);
     return ImageSkiaRep(blended, first_rep.scale_factor());
   }
 
  private:
   const ImageSkia first_;
   const ImageSkia second_;
   double alpha_;
 
   DISALLOW_COPY_AND_ASSIGN(BlendingImageSource);
 };
 
 class MaskedImageSource : public gfx::ImageSkiaSource {
  public:
   MaskedImageSource(const ImageSkia& rgb, const ImageSkia& alpha)
       : rgb_(rgb),
         alpha_(alpha) {
   }
 
+  virtual ~MaskedImageSource() {
+  }
+
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep rgb_rep = rgb_.GetRepresentation(scale_factor);
     ImageSkiaRep alpha_rep = alpha_.GetRepresentation(scale_factor);
     MatchScale(&rgb_rep, &alpha_rep);
     return ImageSkiaRep(SkBitmapOperations::CreateMaskedBitmap(
         rgb_rep.sk_bitmap(), alpha_rep.sk_bitmap()),
                         rgb_rep.scale_factor());
   }
 
  private:
   const ImageSkia rgb_;
   const ImageSkia alpha_;
 
   DISALLOW_COPY_AND_ASSIGN(MaskedImageSource);
 };
 
 class TiledImageSource : public gfx::ImageSkiaSource {
  public:
   TiledImageSource(const ImageSkia& source,
                    int src_x, int src_y,
                    int dst_w, int dst_h)
       : source_(source),
         src_x_(src_x),
         src_y_(src_y),
         dst_w_(dst_w),
         dst_h_(dst_h) {
   }
 
+  virtual ~TiledImageSource() {
+  }
+
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep source_rep = source_.GetRepresentation(scale_factor);
     float scale = ui::GetScaleFactorScale(source_rep.scale_factor());
     return ImageSkiaRep(
         SkBitmapOperations::CreateTiledBitmap(
             source_rep.sk_bitmap(),
             src_x_ * scale, src_y_ * scale, dst_w_ * scale, dst_h_ * scale),
         source_rep.scale_factor());
   }
 
  private:
   const ImageSkia& source_;
   const int src_x_;
   const int src_y_;
   const int dst_w_;
   const int dst_h_;
 
   DISALLOW_COPY_AND_ASSIGN(TiledImageSource);
 };
 
+// ImageSkiaSource which uses SkBitmapOperations::CreateButtonBackground
+// to generate image reps for the target image.
+class ButtonImageSource: public gfx::ImageSkiaSource {
+ public:
+  ButtonImageSource(SkColor color,
+                    const ImageSkia& image,
+                    const ImageSkia& mask)
+      : color_(color),
+        image_(image),
+        mask_(mask) {
+  }
+
+  virtual ~ButtonImageSource() {
+  }
+
+  // gfx::ImageSkiaSource overrides:
+  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
+    ImageSkiaRep mask_rep = mask_.GetRepresentation(scale_factor);
+    MatchScale(&image_rep, &mask_rep);
+    return ImageSkiaRep(
+        SkBitmapOperations::CreateButtonBackground(color_,
+            image_rep.sk_bitmap(), mask_rep.sk_bitmap()),
+        image_rep.scale_factor());
+  }
+
+ private:
+  const SkColor color_;
+  const ImageSkia image_;
+  const ImageSkia mask_;
+
+  DISALLOW_COPY_AND_ASSIGN(ButtonImageSource);
+};
+
+// ImageSkiaSource which uses SkBitmap::extractSubset to generate image reps
+// for the target image.
+class ExtractSubsetImageSource: public gfx::ImageSkiaSource {
+ public:
+  ExtractSubsetImageSource(const gfx::ImageSkia& image,
+                           const gfx::Rect& subset_bounds)
+      : image_(image),
+        subset_bounds_(subset_bounds) {
+  }
+
+  ~ExtractSubsetImageSource() {
+  }
+
+  // gfx::ImageSkiaSource overrides:
+  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
+    SkIRect subset_bounds_in_pixel = RectToSkIRect(subset_bounds_.Scale(
+        ui::GetScaleFactorScale(image_rep.scale_factor())));
+    SkBitmap dst;
+    bool success = image_rep.sk_bitmap().extractSubset(&dst,
+                                                       subset_bounds_in_pixel);
+    DCHECK(success);
+    return gfx::ImageSkiaRep(dst, image_rep.scale_factor());
+  }
+
+ private:
+  const gfx::ImageSkia image_;
+  const gfx::Rect subset_bounds_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtractSubsetImageSource);
+};
+
 }  // namespace;
 
 // static
 ImageSkia ImageSkiaOperations::CreateBlendedImage(const ImageSkia& first,
                                                   const ImageSkia& second,
                                                   double alpha) {
   return ImageSkia(new BlendingImageSource(first, second, alpha), first.size());
 }
 
 // static
@@ skipping 11 matching lines @@
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateResizedImage(
     const ImageSkia& source,
     const gfx::Size& target_size_in_dip) {
   return ImageSkia(new ResizingImageSource(source, target_size_in_dip),
                    target_size_in_dip);
 }
 
+// static
+ImageSkia ImageSkiaOperations::CreateButtonBackground(SkColor color,

[sky, 2012/07/16 21:23:40]

This is only called in one place, should it be moved there? Especially since its
so specialized.

[pkotwicz, 2012/07/17 01:15:41]

I would rather keep it here, especially as it is part of SkBitmapOperations. I
would rather err on the side of adding too many methods to ImageSkiaOperations
such that it is easier to notice similarities for now.

+                                                      const ImageSkia& image,
+                                                      const ImageSkia& mask) {
+  return ImageSkia(new ButtonImageSource(color, image, mask), mask.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::ExtractSubset(const ImageSkia& image,
+                                             const Rect& subset_bounds) {
+  gfx::Rect clipped_bounds = subset_bounds.Intersect(gfx::Rect(image.size()));
+  if (image.isNull() || clipped_bounds.IsEmpty()) {
+    return ImageSkia();
+  }
+
+  return ImageSkia(new ExtractSubsetImageSource(image, clipped_bounds),
+                   clipped_bounds.size());
+}
+
 }  // namespace gfx