Makes ImageSkia more like SkBitmap

ui/gfx/image/image_skia.cc

Index: ui/gfx/image/image_skia.cc
diff --git a/ui/gfx/image/image_skia.cc b/ui/gfx/image/image_skia.cc
index 3c2e94f867221b4240065aef0652376daca0b435..f8aff65a3600865042eb0736277b271fd2de1bae 100644
--- a/ui/gfx/image/image_skia.cc
+++ b/ui/gfx/image/image_skia.cc
@@ -8,139 +8,178 @@
 #include <cmath>
 
 #include "base/logging.h"
-#include "base/stl_util.h"
+#include "ui/gfx/size.h"
+#include "base/message_loop.h"
+#include "third_party/skia/include/core/SkPixelRef.h"
 
 namespace gfx {
 
-ImageSkia::ImageSkia(const SkBitmap* bitmap)
-    : size_(bitmap->width(), bitmap->height()),
-      mip_map_build_pending_(false) {
-  CHECK(bitmap);
-  // TODO(pkotwicz): Add a CHECK to ensure that !bitmap->isNull()
-  bitmaps_.push_back(bitmap);
-}
-
-ImageSkia::ImageSkia(const std::vector<const SkBitmap*>& bitmaps)
-    : bitmaps_(bitmaps),
-      mip_map_build_pending_(false) {
-  CHECK(!bitmaps_.empty());
-  // TODO(pkotwicz): Add a CHECK to ensure that !bitmap->isNull() for each
-  // vector element.
-  // Assume that the smallest bitmap represents 1x scale factor.
-  for (size_t i = 0; i < bitmaps_.size(); ++i) {
-    gfx::Size bitmap_size(bitmaps_[i]->width(), bitmaps_[i]->height());
-    if (size_.IsEmpty() || bitmap_size.GetArea() < size_.GetArea())
-      size_ = bitmap_size;
+namespace internal {
+
+// A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a
+// refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's
+// information.
+class ImageSkiaStorage : public base::RefCounted<ImageSkiaStorage> {
+ public:
+  ImageSkiaStorage() {
   }
-}
 
-ImageSkia::~ImageSkia() {
-  STLDeleteElements(&bitmaps_);
-}
+  void add_bitmap(const SkBitmap& bitmap) {
+    bitmaps_.push_back(bitmap);
+  }
 
-void ImageSkia::BuildMipMap() {
-  mip_map_build_pending_ = true;
-}
+  const std::vector<SkBitmap>& bitmaps() const { return bitmaps_; }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas, int x, int y) {
-  SkPaint p;
-  DrawToCanvasInt(canvas, x, y, p);
-}
+  void set_size(gfx::Size size) { size_ = size; }

[sky, 2012/05/04 20:12:25]

const gfx::Size& (same for next line).

+  gfx::Size size() const { return size_; }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas,
-                                int x, int y,
-                                const SkPaint& paint) {
+ private:
+  ~ImageSkiaStorage() {
+  }
 
-  if (IsZeroSized())
-    return;
+  // Bitmaps at different densities.
+  std::vector<SkBitmap> bitmaps_;
 
-  SkMatrix m = canvas->sk_canvas()->getTotalMatrix();
-  float scale_x = std::abs(SkScalarToFloat(m.getScaleX()));
-  float scale_y = std::abs(SkScalarToFloat(m.getScaleY()));
+  // Size of the image in DIP.
+  gfx::Size size_;
 
-  const SkBitmap* bitmap = GetBitmapForScale(scale_x, scale_y);
+  friend class base::RefCounted<ImageSkiaStorage>;
+};
 
-  if (mip_map_build_pending_) {
-    const_cast<SkBitmap*>(bitmap)->buildMipMap();
-    mip_map_build_pending_ = false;
-  }
+}  // internal
+
+ImageSkia::ImageSkia() : storage_(NULL) {
+}
 
-  float bitmap_scale_x = static_cast<float>(bitmap->width()) / width();
-  float bitmap_scale_y = static_cast<float>(bitmap->height()) / height();
+ImageSkia::ImageSkia(const SkBitmap& bitmap) {
+  Init(bitmap);
+}
 
-  canvas->Save();
-  canvas->sk_canvas()->scale(1.0f / bitmap_scale_x,
-                             1.0f / bitmap_scale_y);
-  canvas->sk_canvas()->drawBitmap(*bitmap, SkFloatToScalar(x * bitmap_scale_x),
-                                  SkFloatToScalar(y * bitmap_scale_y));
-  canvas->Restore();
+ImageSkia::ImageSkia(const SkBitmap& bitmap, float dip_scale_factor) {
+  Init(bitmap, dip_scale_factor);
 }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas,
-                                int src_x, int src_y, int src_w, int src_h,
-                                int dest_x, int dest_y, int dest_w, int dest_h,
-                                bool filter) {
-  SkPaint p;
-  DrawToCanvasInt(canvas, src_x, src_y, src_w, src_h, dest_x, dest_y,
-                  dest_w, dest_h, filter, p);
+ImageSkia::ImageSkia(const SkBitmap* bitmap) {
+  Init(*bitmap);
+
+  if (MessageLoop::current()) {

[sky, 2012/05/04 20:12:25]

Document why you use DeleteSoon.

+    MessageLoop::current()->DeleteSoon(FROM_HERE, bitmap);
+  } else {
+    // Hit in unittests.
+    delete bitmap;
+  }
 }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas,
-                                int src_x, int src_y, int src_w, int src_h,
-                                int dest_x, int dest_y, int dest_w, int dest_h,
-                                bool filter,
-                                const SkPaint& paint) {
-  if (IsZeroSized())
-    return;
+ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
+}
 
-  SkMatrix m = canvas->sk_canvas()->getTotalMatrix();
-  float scale_x = std::abs(SkScalarToFloat(m.getScaleX()));
-  float scale_y = std::abs(SkScalarToFloat(m.getScaleY()));
+ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
+  storage_ = other.storage_;
+  return *this;
+}
 
-  const SkBitmap* bitmap = GetBitmapForScale(scale_x, scale_y);
+ImageSkia& ImageSkia::operator=(const SkBitmap& other) {
+  Init(other);
+  return *this;
+}
 
-  if (mip_map_build_pending_) {
-    const_cast<SkBitmap*>(bitmap)->buildMipMap();
-    mip_map_build_pending_ = false;
+ImageSkia::operator SkBitmap&() const {
+  if (isNull()) {
+    // TODO(pkotwicz): This is temporary till conversion to gfx::ImageSkia is
+    // done.
+    // Static null bitmap such that we are not returning a temporary.
+    static SkBitmap* null_bitmap = new SkBitmap();
+    return *null_bitmap;
   }
 
-  float bitmap_scale_x = static_cast<float>(bitmap->width()) / width();
-  float bitmap_scale_y = static_cast<float>(bitmap->height()) / height();
+  std::vector<SkBitmap>& v = const_cast<std::vector<SkBitmap>&>(bitmaps());
+  return v[0];
+}
 
-  canvas->Save();
-  canvas->sk_canvas()->scale(1.0f / bitmap_scale_x,
-                             1.0f / bitmap_scale_y);
-  canvas->DrawBitmapFloat(*bitmap,
-                        src_x * bitmap_scale_x, src_y * bitmap_scale_x,
-                        src_w * bitmap_scale_x, src_h * bitmap_scale_y,
-                        dest_x * bitmap_scale_x, dest_y * bitmap_scale_y,
-                        dest_w * bitmap_scale_x, dest_h * bitmap_scale_y,
-                        filter, paint);
+ImageSkia::~ImageSkia() {
+}
 
-  canvas->Restore();
+void ImageSkia::AddBitmapForScale(const SkBitmap& bitmap,
+                                  float dip_scale_factor) {
+  DCHECK(!bitmap.isNull());
+
+  if (isNull())

[sky, 2012/05/04 20:12:25]

Can you add some error checking here (just for debugging)?
How come it's safe to drop the DIP on the floor if not empty?

[pkotwicz, 2012/05/04 22:35:36]

Right now we assume that bitmap sizes are relative to scale factor. Thus a
bitmap which is twice as wide as a bitmap of scale factor 1 has scale factor 2.
This will be wrong for scale factors other than two because of rounding errors.
(eg a 1x bitmap 11px wide will 15px wide in it's 1.4x version)
We need the device scale factor for the first bitmap because we don't know what
scale factor it is at. It is conceivable to have an object with only a bitmap at
scale factor 2.

[sky, 2012/05/04 23:41:42]

Can you make what you just described a DCHECK? At a minimum the width/height
should be bigger, right?

+    Init(bitmap, dip_scale_factor);
+  else
+    storage_->add_bitmap(bitmap);
 }
 
-const SkBitmap* ImageSkia::GetBitmapForScale(float x_scale_factor,
-                                             float y_scale_factor) const {
+bool ImageSkia::GetBitmapForScale(float x_scale_factor,

[sky, 2012/05/04 20:12:25]

Can this return a const SkBitmap& ?

[pkotwicz, 2012/05/04 22:35:36]

I am not sure.
What would we return in the case where we have empty()? We could do the same
hack that I am doing for
ImageSkia::operator SkBitmap&() const and return a reference to a static.

[sky, 2012/05/04 23:41:42]

Yes.

+                                  float y_scale_factor,
+                                  const SkBitmap** bitmap,
+                                  float* bitmap_scale_factor) const {
+  if (empty())
+    return false;
+
   // Get the desired bitmap width and height given |x_scale_factor|,
-  // |y_scale_factor| and |size_| at 1x density.
-  float desired_width = size_.width() * x_scale_factor;
-  float desired_height = size_.height() * y_scale_factor;
+  // |y_scale_factor| and size at 1x density.
+  float desired_width = width() * x_scale_factor;
+  float desired_height = height() * y_scale_factor;
 
+  const std::vector<SkBitmap>& bitmaps = storage_->bitmaps();
   size_t closest_index = 0;
   float smallest_diff = std::numeric_limits<float>::max();
-  for (size_t i = 0; i < bitmaps_.size(); ++i) {
-    if (bitmaps_[i]->isNull())
-      continue;
-
-    float diff = std::abs(bitmaps_[i]->width() - desired_width) +
-        std::abs(bitmaps_[i]->height() - desired_height);
+  for (size_t i = 0; i < bitmaps.size(); ++i) {
+    float diff = std::abs(bitmaps[i].width() - desired_width) +
+        std::abs(bitmaps[i].height() - desired_height);
     if (diff < smallest_diff) {
       closest_index = i;
       smallest_diff = diff;
     }
   }
-  return bitmaps_[closest_index];
+  if (smallest_diff < std::numeric_limits<float>::max()) {
+    *bitmap = &bitmaps[closest_index];
+    *bitmap_scale_factor = bitmaps[closest_index].width() / width();
+    return true;
+  }
+
+  return false;
+}
+
+bool ImageSkia::empty() const {
+  return isNull() || storage_->size().IsEmpty();
+}
+
+int ImageSkia::width() const {
+  return isNull() ? 0 : storage_->size().width();
+}
+
+int ImageSkia::height() const {
+  return isNull() ? 0 : storage_->size().height();
+}
+
+bool ImageSkia::extractSubset(ImageSkia* dst, SkIRect& subset) const {
+  if (isNull())
+    return false;
+  SkBitmap dst_bitmap;
+  bool return_value  = bitmaps()[0].extractSubset(&dst_bitmap, subset);
+  *dst = ImageSkia(dst_bitmap);
+  return return_value;
+}
+
+const std::vector<SkBitmap>& ImageSkia::bitmaps() const {
+  return storage_->bitmaps();
+}
+
+void ImageSkia::Init(const SkBitmap& bitmap) {
+  Init(bitmap, 1.0f);
+}
+
+void ImageSkia::Init(const SkBitmap& bitmap, float scale_factor) {
+  DCHECK(scale_factor >= 1.0f);
+  if (bitmap.isNull()) {
+    storage_ = NULL;
+    return;
+  }
+  storage_ = new internal::ImageSkiaStorage();
+  storage_->set_size(gfx::Size(static_cast<int>(bitmap.width() / scale_factor),
+      static_cast<int>(bitmap.height() / scale_factor)));
+  storage_->add_bitmap(bitmap);
 }
 
 }  // namespace gfx