Makes ImageSkia more like SkBitmap

ui/gfx/image/image_skia.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.h"
 
 #include <limits>
 #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);
+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() {
+  }
+
+  void add_bitmap(const SkBitmap& bitmap) {
+    bitmaps_.push_back(bitmap);
+  }
+
+  const std::vector<SkBitmap>& bitmaps() const { return bitmaps_; }
+
+  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_; }
+
+ private:
+  ~ImageSkiaStorage() {
+  }
+
+  // Bitmaps at different densities.
+  std::vector<SkBitmap> bitmaps_;
+
+  // Size of the image in DIP.
+  gfx::Size size_;
+
+  friend class base::RefCounted<ImageSkiaStorage>;
+};
+
+}  // internal
+
+ImageSkia::ImageSkia() : storage_(NULL) {
 }
 
-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;
+ImageSkia::ImageSkia(const SkBitmap& bitmap) {
+  Init(bitmap);
+}
+
+ImageSkia::ImageSkia(const SkBitmap& bitmap, float dip_scale_factor) {
+  Init(bitmap, dip_scale_factor);
+}
+
+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;
   }
 }
 
-ImageSkia::~ImageSkia() {
-  STLDeleteElements(&bitmaps_);
+ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
 }
 
-void ImageSkia::BuildMipMap() {
-  mip_map_build_pending_ = true;
+ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
+  storage_ = other.storage_;
+  return *this;
 }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas, int x, int y) {
-  SkPaint p;
-  DrawToCanvasInt(canvas, x, y, p);
+ImageSkia& ImageSkia::operator=(const SkBitmap& other) {
+  Init(other);
+  return *this;
 }
 
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas,
-                                int x, int y,
-                                const SkPaint& paint) {
-
-  if (IsZeroSized())
-    return;
-
-  SkMatrix m = canvas->sk_canvas()->getTotalMatrix();
-  float scale_x = std::abs(SkScalarToFloat(m.getScaleX()));
-  float scale_y = std::abs(SkScalarToFloat(m.getScaleY()));
-
-  const SkBitmap* bitmap = GetBitmapForScale(scale_x, scale_y);
-
-  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();
-
-  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();
+  std::vector<SkBitmap>& v = const_cast<std::vector<SkBitmap>&>(bitmaps());
+  return v[0];
 }
 
-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() {
 }
 
-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;
+void ImageSkia::AddBitmapForScale(const SkBitmap& bitmap,
+                                  float dip_scale_factor) {
+  DCHECK(!bitmap.isNull());
 
-  SkMatrix m = canvas->sk_canvas()->getTotalMatrix();
-  float scale_x = std::abs(SkScalarToFloat(m.getScaleX()));
-  float scale_y = std::abs(SkScalarToFloat(m.getScaleY()));
-
-  const SkBitmap* bitmap = GetBitmapForScale(scale_x, scale_y);
-
-  if (mip_map_build_pending_) {
-    const_cast<SkBitmap*>(bitmap)->buildMipMap();
-    mip_map_build_pending_ = false;
-  }
-
-  float bitmap_scale_x = static_cast<float>(bitmap->width()) / width();
-  float bitmap_scale_y = static_cast<float>(bitmap->height()) / height();
-
-  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);
-
-  canvas->Restore();
+  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