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);
+    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);

[stevenjb, 2012/07/02 22:31:34]

I assume that image_rep will always be scaled appropriately based on
scale_factor, even if a larger image isn't provided? (Otherwise it seems like
scaling height and width below could cause problems if the high res image were
missing).

[oshima, 2012/07/02 22:42:06]

It may not, and that's why I'm using the image_rep.scale_factor() instead of
scale_factor passed to this function below. If 2x resource is not available,
imgage_rep.scale_factor() returns 1x, and will give the correct subset rect for
1x image. Note that width and height are in dip, so it needs to be multiplied
by scale factor in order for extractSubset to work.

[stevenjb, 2012/07/03 16:38:38]

Ah, I see, I was confused by scale vs. scale_factor. Cool, looks good then.

+
+    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
+    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);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkIcon
 // TODO(stevenjb): Separate class implementation from the definition.
@@ skipping 486 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