Add support for multi resolution icons

ui/gfx/image.cc

 // Copyright (c) 2011 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.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/stl_util-inl.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 #if defined(OS_LINUX)
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <glib-object.h>
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/gtk_util.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(OS_MACOSX)
 // This is a wrapper around gfx::NSImageToSkBitmap() because this cross-platform
 // file cannot include the [square brackets] of ObjC.
-const SkBitmap* NSImageToSkBitmap(NSImage* image);
+bool NSImageToSkBitmaps(NSImage* image, std::vector<const SkBitmap*>& bitmaps);
 #endif
 
 #if defined(OS_LINUX)
 const SkBitmap* GdkPixbufToSkBitmap(GdkPixbuf* pixbuf) {
   gfx::CanvasSkia canvas(gdk_pixbuf_get_width(pixbuf),
                          gdk_pixbuf_get_height(pixbuf),
                          /*is_opaque=*/false);
   canvas.DrawGdkPixbuf(pixbuf, 0, 0);
   return new SkBitmap(canvas.ExtractBitmap());
 }
@@ skipping 37 matching lines @@
 
   Image::RepresentationType type() const { return type_; }
 
  private:
   Image::RepresentationType type_;
 };
 
 class SkBitmapRep : public ImageRep {
  public:
   explicit SkBitmapRep(const SkBitmap* bitmap)
+      : ImageRep(Image::kSkBitmapRep) {
+    CHECK(bitmap);
+    bitmaps_.push_back(bitmap);
+  }
+
+  explicit SkBitmapRep(const std::vector<const SkBitmap*>& bitmaps)
       : ImageRep(Image::kSkBitmapRep),
-        bitmap_(bitmap) {
-    CHECK(bitmap);
+        bitmaps_(bitmaps) {
+    CHECK(!bitmaps_.empty());
   }
 
   virtual ~SkBitmapRep() {
-    delete bitmap_;
-    bitmap_ = NULL;
+    STLDeleteElements(&bitmaps_);
   }
 
-  const SkBitmap* bitmap() const { return bitmap_; }
+  const SkBitmap* bitmap() const { return bitmaps_[0]; }
+
+  const std::vector<const SkBitmap*>& bitmaps() const { return bitmaps_; }
 
  private:
-  const SkBitmap* bitmap_;
+  std::vector<const SkBitmap*> bitmaps_;
 
   DISALLOW_COPY_AND_ASSIGN(SkBitmapRep);
 };
 
 #if defined(OS_LINUX)
 class GdkPixbufRep : public ImageRep {
  public:
   explicit GdkPixbufRep(GdkPixbuf* pixbuf)
       : ImageRep(Image::kGdkPixbufRep),
         pixbuf_(pixbuf) {
@@ skipping 40 matching lines @@
 #endif
 
 }  // namespace internal
 
 Image::Image(const SkBitmap* bitmap)
     : default_representation_(Image::kSkBitmapRep) {
   internal::SkBitmapRep* rep = new internal::SkBitmapRep(bitmap);
   AddRepresentation(rep);
 }
 
+Image::Image(const std::vector<const SkBitmap*>& bitmaps)
+    : default_representation_(Image::kSkBitmapRep) {
+  internal::SkBitmapRep* rep = new internal::SkBitmapRep(bitmaps);
+  AddRepresentation(rep);
+}
+
 #if defined(OS_LINUX)
 Image::Image(GdkPixbuf* pixbuf)
     : default_representation_(Image::kGdkPixbufRep) {
   internal::GdkPixbufRep* rep = new internal::GdkPixbufRep(pixbuf);
   AddRepresentation(rep);
 }
 #endif
 
 #if defined(OS_MACOSX)
 Image::Image(NSImage* image) : default_representation_(Image::kNSImageRep) {
@@ skipping 68 matching lines @@
     internal::SkBitmapRep* rep = NULL;
 #if defined(OS_LINUX)
     if (default_representation_ == Image::kGdkPixbufRep) {
       internal::GdkPixbufRep* pixbuf_rep = default_rep->AsGdkPixbufRep();
       rep = new internal::SkBitmapRep(
           internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf()));
     }
 #elif defined(OS_MACOSX)
     if (default_representation_ == Image::kNSImageRep) {
       internal::NSImageRep* nsimage_rep = default_rep->AsNSImageRep();
-      rep = new internal::SkBitmapRep(
-          internal::NSImageToSkBitmap(nsimage_rep->image()));
+      std::vector<const SkBitmap*> bitmaps;
+      if (internal::NSImageToSkBitmaps(nsimage_rep->image(), bitmaps))
+        rep = new internal::SkBitmapRep(bitmaps);
     }
 #endif
     CHECK(rep);
     AddRepresentation(rep);
     return rep;
   }
 
   // Handle Skia-to-native conversions.
   if (default_rep->type() == Image::kSkBitmapRep) {
     internal::SkBitmapRep* skia_rep = default_rep->AsSkBitmapRep();
     internal::ImageRep* native_rep = NULL;
 #if defined(OS_LINUX)
     if (rep_type == Image::kGdkPixbufRep) {
       GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(skia_rep->bitmap());
       native_rep = new internal::GdkPixbufRep(pixbuf);
     }
 #elif defined(OS_MACOSX)
     if (rep_type == Image::kNSImageRep) {
-      NSImage* image = gfx::SkBitmapToNSImage(*(skia_rep->bitmap()));
+      NSImage* image = gfx::SkBitmapsToNSImage(skia_rep->bitmaps());
       base::mac::NSObjectRetain(image);
       native_rep = new internal::NSImageRep(image);
     }
 #endif
     CHECK(native_rep);
     AddRepresentation(native_rep);
     return native_rep;
   }
 
   // Something went seriously wrong...
   return NULL;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) {
   representations_.insert(std::make_pair(rep->type(), rep));
 }
 
+size_t Image::GetNumberOfSkBitmaps() {
+  return GetRepresentation(Image::kSkBitmapRep)->AsSkBitmapRep()->
+      bitmaps().size();
+}
+
+const SkBitmap* Image::GetSkBitmapAtIndex(size_t index) {
+  return GetRepresentation(Image::kSkBitmapRep)->AsSkBitmapRep()->
+      bitmaps()[index];
+}
+
 }  // namespace gfx