Use ImageSkiaSource to create ImageSkia from ImagePNGReps

ui/gfx/image/image.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.h"
 
 #include <algorithm>
+#include <set>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/size.h"
 
 #if !defined(OS_IOS)
 #include "ui/gfx/codec/png_codec.h"
 #endif
 
 #if defined(OS_IOS)
 #include "base/mac/foundation_util.h"
 #include "ui/gfx/image/image_skia_util_ios.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "ui/gfx/image/image_skia_util_mac.h"
 #endif
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(OS_IOS)
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
     UIImage* uiimage);
 // Caller takes ownership of the returned UIImage.
 UIImage* CreateUIImageFromPNG(
-    const std::vector<gfx::ImagePNGRep>& image_png_reps);
+    const std::vector<ImagePNGRep>& image_png_reps);
 gfx::Size UIImageSize(UIImage* image);
 #elif defined(OS_MACOSX)
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
     NSImage* nsimage);
 // Caller takes ownership of the returned NSImage.
-NSImage* NSImageFromPNG(const std::vector<gfx::ImagePNGRep>& image_png_reps,
+NSImage* NSImageFromPNG(const std::vector<ImagePNGRep>& image_png_reps,
                         CGColorSpaceRef color_space);
 gfx::Size NSImageSize(NSImage* image);
 #endif // defined(OS_MACOSX)
 
 #if defined(OS_IOS)
 ImageSkia* ImageSkiaFromPNG(
-    const std::vector<gfx::ImagePNGRep>& image_png_reps);
+    const std::vector<ImagePNGRep>& image_png_reps);
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     const ImageSkia* skia);
 #else
 // Returns a 16x16 red image to visually show error in decoding PNG.
 // Caller takes ownership of returned ImageSkia.
 ImageSkia* GetErrorImageSkia() {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
   bitmap.allocPixels();
   bitmap.eraseARGB(0xff, 0xff, 0, 0);
-  return new gfx::ImageSkia(gfx::ImageSkiaRep(bitmap, 1.0f));
+  return new ImageSkia(ImageSkiaRep(bitmap, 1.0f));
 }
 
+class PNGImageSource : public ImageSkiaSource {
+ public:
+  PNGImageSource() {}
+  virtual ~PNGImageSource() {}
+
+  virtual ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
+    if (image_skia_reps_.empty())
+      return ImageSkiaRep();
+
+    const ImageSkiaRep* rep = NULL;
+    // gfx::ImageSkia passes one of the resource scale factor, and

[pkotwicz, 2014/06/19 21:09:09]

How about: "gfx::ImageSkia passes one of the resource scale factors. The source
should return:
1) The ImageSkiaRep with the highest scale if all of the available scales ..."

Aside: It would be nice if we can use either 'scale factor' or 'scale' in the
function comments.

[oshima, 2014/06/19 21:29:58]

I'm planning to do some cleanup there.

[oshima, 2014/06/19 21:29:58]

Done.

+    // the source should return
+    // 1) the highest scale if all available scales are smaller than |scale|.
+    // 2) or the smallest one that is larger than |scale|.
+    for (ImageSkiaRepSet::const_iterator iter = image_skia_reps_.begin();
+         iter != image_skia_reps_.end(); ++iter) {
+      if ((*iter).scale() == scale)
+        return (*iter);
+      if (!rep || rep->scale() < (*iter).scale())
+        rep = &(*iter);
+      if (rep->scale() >= scale)
+        break;
+    }
+    return rep ? *rep : ImageSkiaRep();
+  }
+
+  const gfx::Size size() const {
+    return size_;
+  }
+
+  bool AddPngData(const ImagePNGRep& png_rep) {
+    const gfx::ImageSkiaRep rep = ToImageSkiaRep(png_rep);

[pkotwicz, 2014/06/19 21:09:09]

Nit: the const here is unnecessary

[oshima, 2014/06/19 21:29:58]

I think this is fine. It guarantees that rep won't change in between. I
understand it's not necessary, but it's not harmful either.

[pkotwicz, 2014/06/19 21:41:46]

We insert |rep| by copy into |image_skia_reps_| so the const does not really
help much.

+    if (rep.is_null())
+      return false;
+    if (size_.IsEmpty())
+      size_ = gfx::Size(rep.GetWidth(), rep.GetHeight());
+    image_skia_reps_.insert(rep);
+    return true;
+  }
+
+  static ImageSkiaRep ToImageSkiaRep(const ImagePNGRep& png_rep) {
+    scoped_refptr<base::RefCountedMemory> raw_data = png_rep.raw_data;
+    CHECK(raw_data.get());
+    SkBitmap bitmap;
+    if (!PNGCodec::Decode(raw_data->front(), raw_data->size(),
+                               &bitmap)) {
+      LOG(ERROR) << "Unable to decode PNG for " << png_rep.scale << ".";
+      return ImageSkiaRep();
+    }
+    return ImageSkiaRep(bitmap, png_rep.scale);
+  }
+
+ private:
+  struct Compare {
+    bool operator()(const ImageSkiaRep& rep1, const ImageSkiaRep& rep2) {
+      return rep1.scale() < rep2.scale();
+    }
+  };
+
+  typedef std::set<ImageSkiaRep, Compare> ImageSkiaRepSet;
+  ImageSkiaRepSet image_skia_reps_;
+  gfx::Size size_;
+
+  DISALLOW_COPY_AND_ASSIGN(PNGImageSource);
+};
+
 ImageSkia* ImageSkiaFromPNG(
-    const std::vector<gfx::ImagePNGRep>& image_png_reps) {
+    const std::vector<ImagePNGRep>& image_png_reps) {
   if (image_png_reps.empty())
     return GetErrorImageSkia();
+  scoped_ptr<PNGImageSource> image_source(new PNGImageSource);
 
-  scoped_ptr<gfx::ImageSkia> image_skia(new ImageSkia());
   for (size_t i = 0; i < image_png_reps.size(); ++i) {
-    scoped_refptr<base::RefCountedMemory> raw_data =
-        image_png_reps[i].raw_data;
-    CHECK(raw_data.get());
-    SkBitmap bitmap;
-    if (!gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
-                               &bitmap)) {
-      LOG(ERROR) << "Unable to decode PNG for "
-                 << image_png_reps[i].scale
-                 << ".";
+    if (!image_source->AddPngData(image_png_reps[i]))
       return GetErrorImageSkia();
-    }
-    image_skia->AddRepresentation(gfx::ImageSkiaRep(
-        bitmap, image_png_reps[i].scale));
   }
-  return image_skia.release();
+  const gfx::Size& size = image_source->size();
+  DCHECK(!size.IsEmpty());
+  if (size.IsEmpty())
+    return GetErrorImageSkia();
+  return new ImageSkia(image_source.release(), size);
 }
 
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     const ImageSkia* image_skia) {
   ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(1.0f);
 
   scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
   if (image_skia_rep.scale() != 1.0f ||
-      !gfx::PNGCodec::EncodeBGRASkBitmap(image_skia_rep.sk_bitmap(), false,
+      !PNGCodec::EncodeBGRASkBitmap(image_skia_rep.sk_bitmap(), false,
           &png_bytes->data())) {
     return NULL;
   }
   return png_bytes;
 }
 #endif
 
 class ImageRepPNG;
 class ImageRepSkia;
 class ImageRepCocoa;
@@ skipping 189 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoa);
 };
 #endif  // defined(OS_MACOSX)
 
 // The Storage class acts similarly to the pixels in a SkBitmap: the Image
 // class holds a refptr instance of Storage, which in turn holds all the
 // ImageReps. This way, the Image can be cheaply copied.
 class ImageStorage : public base::RefCounted<ImageStorage> {
  public:
-  ImageStorage(gfx::Image::RepresentationType default_type)
+  ImageStorage(Image::RepresentationType default_type)
       : default_representation_type_(default_type),
 #if defined(OS_MACOSX) && !defined(OS_IOS)
         default_representation_color_space_(
             base::mac::GetGenericRGBColorSpace()),
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
         representations_deleter_(&representations_) {
   }
 
-  gfx::Image::RepresentationType default_representation_type() {
+  Image::RepresentationType default_representation_type() {
     return default_representation_type_;
   }
-  gfx::Image::RepresentationMap& representations() { return representations_; }
+  Image::RepresentationMap& representations() { return representations_; }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   void set_default_representation_color_space(CGColorSpaceRef color_space) {
     default_representation_color_space_ = color_space;
   }
   CGColorSpaceRef default_representation_color_space() {
     return default_representation_color_space_;
   }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
  private:
   friend class base::RefCounted<ImageStorage>;
 
   ~ImageStorage() {}
 
   // The type of image that was passed to the constructor. This key will always
   // exist in the |representations_| map.
-  gfx::Image::RepresentationType default_representation_type_;
+  Image::RepresentationType default_representation_type_;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // The default representation's colorspace. This is used for converting to
   // NSImage. This field exists to compensate for PNGCodec not writing or
   // reading colorspace ancillary chunks. (sRGB, iCCP).
   // Not owned.
   CGColorSpaceRef default_representation_color_space_;
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   // All the representations of an Image. Size will always be at least one, with
   // more for any converted representations.
-  gfx::Image::RepresentationMap representations_;
+  Image::RepresentationMap representations_;
 
   STLValueDeleter<Image::RepresentationMap> representations_deleter_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageStorage);
 };
 
 }  // namespace internal
 
 Image::Image() {
   // |storage_| is NULL for empty Images.
@@ skipping 48 matching lines @@
 Image& Image::operator=(const Image& other) {
   storage_ = other.storage_;
   return *this;
 }
 
 Image::~Image() {
 }
 
 // static
 Image Image::CreateFrom1xBitmap(const SkBitmap& bitmap) {
-  return gfx::Image(ImageSkia::CreateFrom1xBitmap(bitmap));
+  return Image(ImageSkia::CreateFrom1xBitmap(bitmap));
 }
 
 // static
 Image Image::CreateFrom1xPNGBytes(const unsigned char* input,
                                   size_t input_size) {
   if (input_size == 0u)
-    return gfx::Image();
+    return Image();
 
   scoped_refptr<base::RefCountedBytes> raw_data(new base::RefCountedBytes());
   raw_data->data().assign(input, input + input_size);
 
   return CreateFrom1xPNGBytes(raw_data);
 }
 
 Image Image::CreateFrom1xPNGBytes(
     const scoped_refptr<base::RefCountedMemory>& input) {
   if (!input.get() || input->size() == 0u)
-    return gfx::Image();
+    return Image();
 
-  std::vector<gfx::ImagePNGRep> image_reps;
+  std::vector<ImagePNGRep> image_reps;
   image_reps.push_back(ImagePNGRep(input, 1.0f));
-  return gfx::Image(image_reps);
+  return Image(image_reps);
 }
 
 const SkBitmap* Image::ToSkBitmap() const {
   // Possibly create and cache an intermediate ImageRepSkia.
   return ToImageSkia()->bitmap();
 }
 
 const ImageSkia* Image::ToImageSkia() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
   if (!rep) {
@@ skipping 94 matching lines @@
 }
 #endif
 
 scoped_refptr<base::RefCountedMemory> Image::As1xPNGBytes() const {
   if (IsEmpty())
     return new base::RefCountedBytes();
 
   internal::ImageRep* rep = GetRepresentation(kImageRepPNG, false);
 
   if (rep) {
-    const std::vector<gfx::ImagePNGRep>& image_png_reps =
+    const std::vector<ImagePNGRep>& image_png_reps =
         rep->AsImageRepPNG()->image_reps();
     for (size_t i = 0; i < image_png_reps.size(); ++i) {
       if (image_png_reps[i].scale == 1.0f)
         return image_png_reps[i].raw_data;
     }
     return new base::RefCountedBytes();
   }
 
   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
   switch (DefaultRepresentationType()) {
@@ skipping 30 matching lines @@
     return new base::RefCountedBytes();
   }
 
   // Do not insert representations for scale factors other than 1x even if
   // they are available because:
   // - Only the 1x PNG bytes can be accessed.
   // - ImageRepPNG is not used as an intermediate type in converting to a
   //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
   //   ImageRepCocoa).
   std::vector<ImagePNGRep> image_png_reps;
-  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
+  image_png_reps.push_back(ImagePNGRep(png_bytes, 1.0f));
   rep = new internal::ImageRepPNG(image_png_reps);
   AddRepresentation(rep);
   return png_bytes;
 }
 
 SkBitmap Image::AsBitmap() const {
   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
 }
 
 ImageSkia Image::AsImageSkia() const {
@@ skipping 61 matching lines @@
     return 0;
   return GetRepresentation(DefaultRepresentationType(), true)->Height();
 }
 
 gfx::Size Image::Size() const {
   if (IsEmpty())
     return gfx::Size();
   return GetRepresentation(DefaultRepresentationType(), true)->Size();
 }
 
-void Image::SwapRepresentations(gfx::Image* other) {
+void Image::SwapRepresentations(Image* other) {
   storage_.swap(other->storage_);
 }
 
 #if defined(OS_MACOSX)  && !defined(OS_IOS)
 void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
   if (storage_.get())
     storage_->set_default_representation_color_space(color_space);
 }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
@@ skipping 12 matching lines @@
   }
   return it->second;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) const {
   CHECK(storage_.get());
   storage_->representations().insert(std::make_pair(rep->type(), rep));
 }
 
 }  // namespace gfx