Loading/Creating images for mutiple scale factors on the fly

chrome/browser/chromeos/status/network_menu_icon.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 "chrome/browser/chromeos/status/network_menu_icon.h"
 
 #include <algorithm>
 #include <cmath>
+#include <map>
+#include <utility>
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_util.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 using std::max;
 using std::min;
 
 namespace chromeos {
 
 namespace {
 
 // Amount to fade icons while connecting.
@@ skipping 113 matching lines @@
       break;
     case NETWORK_TECHNOLOGY_UNKNOWN:
       break;
   }
   if (id == kUnknownBadgeType)
     return NULL;
   else
     return ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
 }
 
-// Blend source image with a black image to fade the image.
-const gfx::ImageSkia GenerateFadedImage(gfx::ImageSkia source,
-                                        gfx::ImageSkia empty_image,
-                                        double alpha) {
-  gfx::ImageSkia faded_image;
-  std::vector<gfx::ImageSkiaRep> image_reps = source.image_reps();
-  for (size_t i = 0; i < image_reps.size(); ++i) {
-    gfx::ImageSkiaRep image_rep = image_reps[i];
-    ui::ScaleFactor scale_factor = image_rep.scale_factor();
-    gfx::ImageSkiaRep empty_image_rep =
-        empty_image.GetRepresentation(scale_factor);
-    SkBitmap empty_bitmap = empty_image_rep.sk_bitmap();
-    if (empty_image_rep.is_null() ||
-        empty_image_rep.scale_factor() != scale_factor) {
-      empty_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                             image_rep.pixel_width(),
-                             image_rep.pixel_height());
-      empty_bitmap.allocPixels();
-      empty_bitmap.eraseARGB(0, 0, 0, 0);
-      empty_image.AddRepresentation(gfx::ImageSkiaRep(empty_bitmap,
-                                                      scale_factor));
-    }
-    SkBitmap faded_bitmap = SkBitmapOperations::CreateBlendedBitmap(
-        empty_bitmap, image_rep.sk_bitmap(), alpha);
-    faded_image.AddRepresentation(gfx::ImageSkiaRep(faded_bitmap,
-                                  scale_factor));
-  }
-  return faded_image;
+const SkBitmap GetEmptyBitmapOfSameSize(const gfx::ImageSkiaRep& reference) {
+  typedef std::pair<int, int> SizeKey;
+  typedef std::map<SizeKey, SkBitmap> SizeBitmapMap;
+  static SizeBitmapMap* empty_bitmaps_ = new SizeBitmapMap;
+
+  SizeKey key(reference.pixel_width(), reference.pixel_height());
+
+  SizeBitmapMap::iterator iter = empty_bitmaps_->find(key);
+  if (iter != empty_bitmaps_->end())
+    return iter->second;
+
+  SkBitmap empty;
+  empty.setConfig(SkBitmap::kARGB_8888_Config, key.first, key.second);
+  empty.allocPixels();
+  empty.eraseARGB(0, 0, 0, 0);
+  (*empty_bitmaps_)[key] = empty;
+  return empty;
 }
 
-const SkBitmap GetVpnResource(int resource_id) {
+class FadedImageSource : public gfx::ImageSkiaSource {
+ public:
+  FadedImageSource(const gfx::ImageSkia& source, double alpha)
+      : source_(source),
+        alpha_(alpha) {
+  }
+  virtual ~FadedImageSource() {}
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    gfx::ImageSkiaRep image_rep = source_.GetRepresentation(scale_factor);
+    const SkBitmap empty_bitmap = GetEmptyBitmapOfSameSize(image_rep);
+    SkBitmap faded_bitmap = SkBitmapOperations::CreateBlendedBitmap(
+        empty_bitmap, image_rep.sk_bitmap(), alpha_);
+    return gfx::ImageSkiaRep(faded_bitmap, image_rep.scale_factor());
+  }
+
+ private:
+  const gfx::ImageSkia source_;
+  const float alpha_;
+
+  DISALLOW_COPY_AND_ASSIGN(FadedImageSource);
+};
+
+// This defines how we assemble a network icon.
+class NetworkIconImageSource : public gfx::ImageSkiaSource {
+ public:
+  NetworkIconImageSource(const gfx::ImageSkia& icon,
+                         const gfx::ImageSkia* top_left_badge,
+                         const gfx::ImageSkia* top_right_badge,
+                         const gfx::ImageSkia* bottom_left_badge,
+                         const gfx::ImageSkia* bottom_right_badge)
+      : icon_(icon),
+        top_left_badge_(top_left_badge),
+        top_right_badge_(top_right_badge),
+        bottom_left_badge_(bottom_left_badge),
+        bottom_right_badge_(bottom_right_badge) {
+  }
+  virtual ~NetworkIconImageSource() {}
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    gfx::ImageSkiaRep icon_rep = icon_.GetRepresentation(scale_factor);
+    if (icon_rep.is_null())
+      return gfx::ImageSkiaRep();
+    gfx::Canvas canvas(icon_rep.sk_bitmap(), false);

[pkotwicz, 2012/07/02 21:39:36]

Nit: You can just pass in the ImageSkiaRep to the canvas constructor and skip
the next line.

[oshima, 2012/07/02 22:24:58]

ah, nice. done.

+    canvas.sk_canvas()->scale(icon_rep.GetScale(), icon_rep.GetScale());
+    if (top_left_badge_)
+      canvas.DrawImageInt(*top_left_badge_, kBadgeLeftX, kBadgeTopY);
+    if (top_right_badge_)
+      canvas.DrawImageInt(*top_right_badge_,
+                          icon_.width() - top_right_badge_->width(),
+                          kBadgeTopY);
+    if (bottom_left_badge_) {
+      canvas.DrawImageInt(*bottom_left_badge_,
+                          kBadgeLeftX,
+                          icon_.height() - bottom_left_badge_->height());
+    }
+    if (bottom_right_badge_) {
+      canvas.DrawImageInt(*bottom_right_badge_,
+                          icon_.width() - bottom_right_badge_->width(),
+                          icon_.height() - bottom_right_badge_->height());
+    }
+    return gfx::ImageSkiaRep(canvas.ExtractBitmap(), icon_rep.scale_factor());
+  }
+
+ private:
+  const gfx::ImageSkia icon_;
+  const gfx::ImageSkia *top_left_badge_;
+  const gfx::ImageSkia *top_right_badge_;
+  const gfx::ImageSkia *bottom_left_badge_;
+  const gfx::ImageSkia *bottom_right_badge_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSource);
+};
+
+// This defines how we assemble a network menu icon.
+class NetworkMenuIconSource : public gfx::ImageSkiaSource {
+ public:
+  NetworkMenuIconSource(NetworkMenuIcon::ImageType type,
+                        int index,
+                        NetworkMenuIcon::ResourceColorTheme color)
+      : type_(type),
+        index_(index),
+        color_(color) {
+  }
+  virtual ~NetworkMenuIconSource() {}
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    int width, height;
+    gfx::ImageSkia* images;
+    if (type_ == NetworkMenuIcon::ARCS) {
+      if (index_ >= kNumArcsImages)
+        return gfx::ImageSkia();
+      images = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+          color_ == NetworkMenuIcon::COLOR_DARK ?
+          IDR_STATUSBAR_NETWORK_ARCS_DARK : IDR_STATUSBAR_NETWORK_ARCS_LIGHT);
+      width = images->width();
+      height = images->height() / kNumArcsImages;
+    } else {
+      if (index_ >= kNumBarsImages)
+        return gfx::ImageSkia();
+
+      images = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+          color_ == NetworkMenuIcon::COLOR_DARK ?
+          IDR_STATUSBAR_NETWORK_BARS_DARK : IDR_STATUSBAR_NETWORK_BARS_LIGHT);
+      width = images->width();
+      height = images->height() / kNumBarsImages;
+    }
+    gfx::ImageSkiaRep image_rep = images->GetRepresentation(scale_factor);
+
+    float scale = ui::GetScaleFactorScale(image_rep.scale_factor());
+    height *= scale;
+    width *= scale;
+
+    SkIRect subset = SkIRect::MakeXYWH(0, index_ * height, width, height);
+
+    SkBitmap dst_bitmap;
+    image_rep.sk_bitmap().extractSubset(&dst_bitmap, subset);
+    return gfx::ImageSkiaRep(dst_bitmap, image_rep.scale_factor());
+  }
+
+  gfx::Size size() const {
+    // NeworkMenuIcons has the same size in DIP

[pkotwicz, 2012/07/02 21:39:36]

Nit: has->all have

[oshima, 2012/07/02 22:24:58]

Done.

+    return ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+        IDR_STATUSBAR_NETWORK_ARCS_DARK)->size();
+  }
+
+ private:
+  const NetworkMenuIcon::ImageType type_;
+  const int index_;
+  const NetworkMenuIcon::ResourceColorTheme color_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkMenuIconSource);
+};
+
+gfx::ImageSkia CreateVpnImage() {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  const gfx::ImageSkia* ethernet_icon = rb.GetImageSkiaNamed(resource_id);
+  const gfx::ImageSkia* ethernet_icon = rb.GetImageSkiaNamed(IDR_STATUSBAR_VPN);
   const gfx::ImageSkia* vpn_badge = rb.GetImageSkiaNamed(kVpnBadgeId);
-  return NetworkMenuIcon::GenerateImageFromComponents(
-      *ethernet_icon, NULL, NULL, vpn_badge, NULL);
+  return NetworkMenuIcon::GenerateImageFromComponents(*ethernet_icon,
+                                                      NULL,
+                                                      NULL,
+                                                      vpn_badge,
+                                                      NULL);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkIcon
 // TODO(stevenjb): Separate class implementation from the definition.
 
 // Sets up and generates an ImageSkia for a Network icon.
 class NetworkIcon {
@@ skipping 483 matching lines @@
   icon_->UpdateIcon(network);
   // Overlay the VPN badge if connecting to a VPN.
   if (network->type() != TYPE_VPN && cros->virtual_network()) {
     if (cros->virtual_network()->connecting()) {
       const gfx::ImageSkia* vpn_badge = rb.GetImageSkiaNamed(kVpnBadgeId);
       const double animation = GetAnimation();
       animating = true;
       // Even though this is the only place we use vpn_connecting_badge_,
       // it is important that this is a member variable since we set a
       // pointer to it and access that pointer in icon_->GenerateImage().
-      CR_DEFINE_STATIC_LOCAL(gfx::ImageSkia, empty_image, ());
-      vpn_connecting_badge_ = GenerateFadedImage(*vpn_badge, empty_image,
-          animation);
+      vpn_connecting_badge_ = gfx::ImageSkia(
+          new FadedImageSource(*vpn_badge, animation), vpn_badge->size());
       icon_->set_bottom_left_badge(&vpn_connecting_badge_);
     }
   }
   if (!animating)
     animation_connecting_.Stop();
 
   // Set the text to display.
   if (network->type() == TYPE_ETHERNET) {
     if (mode_ == MENU_MODE) {
       text_ = l10n_util::GetStringFUTF16(
@@ skipping 44 matching lines @@
 // Currently we iterate over all the available resolutions in |icon|. This will
 // be wrong once we dynamically load image resolutions.
 // TODO(pkotwicz): Figure out what to do when a new image resolution becomes
 // available.
 const gfx::ImageSkia NetworkMenuIcon::GenerateImageFromComponents(
     const gfx::ImageSkia& icon,
     const gfx::ImageSkia* top_left_badge,
     const gfx::ImageSkia* top_right_badge,
     const gfx::ImageSkia* bottom_left_badge,
     const gfx::ImageSkia* bottom_right_badge) {
-  DCHECK(!icon.empty());
-  gfx::ImageSkia badged;
-  int dip_width = icon.width();
-  int dip_height = icon.height();
-  std::vector<gfx::ImageSkiaRep> image_reps = icon.image_reps();
-  for (std::vector<gfx::ImageSkiaRep>::iterator it = image_reps.begin();
-       it != image_reps.end(); ++it) {
-    gfx::Canvas canvas(*it, false);
-    if (top_left_badge)
-      canvas.DrawImageInt(*top_left_badge, kBadgeLeftX, kBadgeTopY);
-    if (top_right_badge)
-      canvas.DrawImageInt(*top_right_badge,
-                          dip_width - top_right_badge->width(),
-                          kBadgeTopY);
-    if (bottom_left_badge)
-      canvas.DrawImageInt(*bottom_left_badge,
-                          kBadgeLeftX,
-                          dip_height - bottom_left_badge->height());
-    if (bottom_right_badge)
-      canvas.DrawImageInt(*bottom_right_badge,
-                          dip_width - bottom_right_badge->width(),
-                          dip_height - bottom_right_badge->height());
-    badged.AddRepresentation(canvas.ExtractImageSkiaRep());
-  }
-  return badged;
+  return gfx::ImageSkia(new NetworkIconImageSource(icon,
+                                                   top_left_badge,
+                                                   top_right_badge,
+                                                   bottom_left_badge,
+                                                   bottom_right_badge),
+                   icon.size());
 }
 
 // We blend connecting icons with a black image to generate a faded icon.
 const gfx::ImageSkia NetworkMenuIcon::GenerateConnectingImage(
     const gfx::ImageSkia& source) {
-  CR_DEFINE_STATIC_LOCAL(gfx::ImageSkia, empty_badge, ());
-  return GenerateFadedImage(source, empty_badge, kConnectingImageAlpha);
+  return gfx::ImageSkia(new FadedImageSource(source, kConnectingImageAlpha),
+                        source.size());
 }
 
 // Generates and caches an icon image for a network's current state.
 const gfx::ImageSkia NetworkMenuIcon::GetImage(const Network* network,
                                                ResourceColorTheme color) {
   DCHECK(network);
   // Maintain a static (global) icon map. Note: Icons are never destroyed;
   // it is assumed that a finite and reasonable number of network icons will be
   // created during a session.
 
@@ skipping 16 matching lines @@
   } else {
     icon = iter->second;
   }
   // Update and return the icon's image.
   icon->Update();
   return icon->GetImage();
 }
 
 // Returns an icon for a disconnected VPN.
 const gfx::ImageSkia NetworkMenuIcon::GetVpnImage() {
-  static gfx::ImageSkia* vpn_image = NULL;
-  if (vpn_image == NULL)
-    vpn_image = new gfx::ImageSkia(GetVpnResource(IDR_STATUSBAR_VPN));
+  static const gfx::ImageSkia *vpn_image = new gfx::ImageSkia(CreateVpnImage());
   return *vpn_image;
 }
 
 const gfx::ImageSkia NetworkMenuIcon::GetImage(ImageType type,
                                                int index,
                                                ResourceColorTheme color) {
-  int width, height;
-  gfx::ImageSkia* images;
-  if (type == ARCS) {
-    if (index >= kNumArcsImages)
-      return gfx::ImageSkia();
-
-    images = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        color == COLOR_DARK ? IDR_STATUSBAR_NETWORK_ARCS_DARK :
-                              IDR_STATUSBAR_NETWORK_ARCS_LIGHT);
-    width = images->width();
-    height = images->height() / kNumArcsImages;
-  } else {
-    if (index >= kNumBarsImages)
-      return gfx::ImageSkia();
-
-    images = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        color == COLOR_DARK ? IDR_STATUSBAR_NETWORK_BARS_DARK :
-                              IDR_STATUSBAR_NETWORK_BARS_LIGHT);
-    width = images->width();
-    height = images->height() / kNumBarsImages;
-  }
-
-  SkIRect subset = SkIRect::MakeXYWH(0, index * height, width, height);
-  gfx::ImageSkia image;
-  images->extractSubset(&image, subset);
-  return image;
+  NetworkMenuIconSource* source = new NetworkMenuIconSource(type, index, color);
+  return gfx::ImageSkia(source, source->size());
 }
 
 const gfx::ImageSkia NetworkMenuIcon::GetDisconnectedImage(
     ImageType type,
     ResourceColorTheme color) {
   return GetImage(type, 0, color);
 }
 
 const gfx::ImageSkia NetworkMenuIcon::GetConnectedImage(ImageType type,
       ResourceColorTheme color) {
   return GetImage(type, NumImages(type) - 1, color);
 }
 
 int NetworkMenuIcon::NumImages(ImageType type) {
   return (type == ARCS) ? kNumArcsImages : kNumBarsImages;
 }
 
 }  // chromeos