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 "ui/gfx/size.h"
+#include "ui/gfx/screen.h"
 #include "base/stl_util.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);
+  }
+
+  void set_bitmaps(const std::vector<const SkBitmap*>& bitmaps) {
+    bitmaps_ = bitmaps;
+  }
+  const std::vector<const SkBitmap*>& bitmaps() const { return bitmaps_; }
+
+  void set_size(gfx::Size size) { size_ = size; }
+  gfx::Size size() const { return size_; }
+
+ private:
+  ~ImageSkiaStorage() {
+    STLDeleteElements(&bitmaps_);
+  }
+
+  // Bitmaps at different densities.
+  std::vector<const SkBitmap*> bitmaps_;
+
+  // Size of the image in DIP.
+  gfx::Size size_;
+
+  friend class base::RefCounted<ImageSkiaStorage>;
+};
+
+}  // internal
+
+ImageSkia::ImageSkia() : storage_(NULL) {
+}
+
+ImageSkia::ImageSkia(const SkBitmap& bitmap) {
+  Init(new SkBitmap(bitmap));
+}
+
+ImageSkia::ImageSkia(const SkBitmap& bitmap, float scale_factor) {
+  Init(new SkBitmap(bitmap), scale_factor);
+}
+
+ImageSkia::ImageSkia(const SkBitmap* bitmap) {
+  Init(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.
+    : storage_(new internal::ImageSkiaStorage()) {
+  storage_->set_bitmaps(bitmaps);
   // 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;
+  gfx::Size smallest_bitmap_size;
+  for (size_t i = 0; i < bitmaps.size(); ++i) {
+    gfx::Size bitmap_size(bitmaps[i]->width(), bitmaps[i]->height());
+    DCHECK(!bitmaps[i]->isNull());
+    if (smallest_bitmap_size.IsEmpty() ||
+        bitmap_size.GetArea() < smallest_bitmap_size.GetArea())
+      smallest_bitmap_size = bitmap_size;
   }
+  storage_->set_size(smallest_bitmap_size);
+}
+
+ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
+}
+
+ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
+  storage_ = other.storage_;
+  return *this;
+}
+
+ImageSkia& ImageSkia::operator=(const SkBitmap& other) {
+  Init(new SkBitmap(other));
+  return *this;
+}
+
+ImageSkia::operator SkBitmap() const {
+  return isNull() ? SkBitmap() : *bitmaps()[0];
 }
 
 ImageSkia::~ImageSkia() {
-  STLDeleteElements(&bitmaps_);
-}
-
-void ImageSkia::BuildMipMap() {
-  mip_map_build_pending_ = true;
-}
-
-void ImageSkia::DrawToCanvasInt(gfx::Canvas* canvas, int x, int y) {
-  SkPaint p;
-  DrawToCanvasInt(canvas, x, y, p);
-}
-
-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;
-  }
-
-  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();
-}
-
-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);
-}
-
-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;
-
-  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();
 }
 
 const SkBitmap* ImageSkia::GetBitmapForScale(float x_scale_factor,
                                              float y_scale_factor) const {
+  if (isNull())
+    return NULL;
+
   // 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;
 
-  size_t closest_index = 0;
+  const std::vector<const SkBitmap*>& bitmaps = storage_->bitmaps();
+  size_t closest_index = -1;
   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];
+  return closest_index < 0 ? NULL : bitmaps[closest_index];
+}
+
+bool ImageSkia::empty() const {
+  return isNull() || storage_->size().IsEmpty();
+}
+
+int ImageSkia::width() const {
+  return isNull() ? 0 : storage_->size().width();

[oshima, 2012/04/30 21:10:08]

We don't want to exclude the possibility to have images with different size in
DIP and ImageSkia should return the DIP of the image for given density. 

If this is transient and to make transition easier, please add TODO.

+}
+
+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<const SkBitmap*>& ImageSkia::bitmaps() const {
+  return storage_->bitmaps();
+}
+
+void ImageSkia::Init(const SkBitmap* bitmap) {
+#if defined(ENABLE_DIP)
+  Init(bitmap, Screen::GetPrimaryMonitor().device_scale_factor());
+#else
+  Init(bitmap, 1.0f);
+#endif
+}
+
+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(bitmap->width(), bitmap->height()));
+  storage_->add_bitmap(bitmap);
 }
 
 }  // namespace gfx