Cache network icon urls

ash/system/chromeos/network/network_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 "ash/system/chromeos/network/network_icon.h"
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_icon_animation.h"
 #include "ash/system/chromeos/network/network_icon_animation_observer.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/base/webui/web_ui_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkState;
@@ skipping 17 matching lines @@
   const gfx::ImageSkia* top_left;
   const gfx::ImageSkia* top_right;
   const gfx::ImageSkia* bottom_left;
   const gfx::ImageSkia* bottom_right;
 };
 
 //------------------------------------------------------------------------------
 // class used for maintaining a map of network state and images.
 class NetworkIconImpl {
  public:
-  explicit NetworkIconImpl(IconType icon_type);
+  NetworkIconImpl(const std::string& path, IconType icon_type);
 
   // Determines whether or not the associated network might be dirty and if so
   // updates and generates the icon. Does nothing if network no longer exists.
   void Update(const chromeos::NetworkState* network);
 
+  // Returns the cached image url for |image_| based on |scale_factor|.
+  const std::string& GetImageUrl(float scale_factor);
+
   const gfx::ImageSkia& image() const { return image_; }
 
  private:
+  typedef std::map<float, std::string> ImageUrlMap;
+
   // Updates |strength_index_| for wireless networks. Returns true if changed.
   bool UpdateWirelessStrengthIndex(const chromeos::NetworkState* network);
 
   // Updates the local state for cellular networks. Returns true if changed.
   bool UpdateCellularState(const chromeos::NetworkState* network);
 
   // Updates the portal state for wireless networks. Returns true if changed.
   bool UpdatePortalState(const chromeos::NetworkState* network);
 
   // Updates the VPN badge. Returns true if changed.
   bool UpdateVPNBadge();
 
   // Gets |badges| based on |network| and the current state.
   void GetBadges(const NetworkState* network, Badges* badges);
 
   // Gets the appropriate icon and badges and composites the image.
   void GenerateImage(const chromeos::NetworkState* network);
 
+  // Network path, used for debugging.
+  std::string network_path_;
+
   // Defines color theme and VPN badging
   const IconType icon_type_;
 
   // Cached state of the network when the icon was last generated.
   std::string state_;
 
   // Cached strength index of the network when the icon was last generated.
   int strength_index_;
 
   // Cached technology badge for the network when the icon was last generated.
   const gfx::ImageSkia* technology_badge_;
 
   // Cached vpn badge for the network when the icon was last generated.
   const gfx::ImageSkia* vpn_badge_;
 
   // Cached roaming state of the network when the icon was last generated.
   std::string roaming_state_;
 
   // Cached portal state of the network when the icon was last generated.
   bool behind_captive_portal_;
 
   // Generated icon image.
   gfx::ImageSkia image_;
 
+  // Map of cached image urls by scale factor. Cleared whenever image_ is
+  // generated.
+  ImageUrlMap image_urls_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkIconImpl);
 };
 
 //------------------------------------------------------------------------------
 // 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.
 
 typedef std::map<std::string, NetworkIconImpl*> NetworkIconMap;
 
@@ skipping 131 matching lines @@
  private:
   const gfx::ImageSkia icon_;
   const Badges badges_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSource);
 };
 
 //------------------------------------------------------------------------------
 // Utilities for extracting icon images.
 
+// A struct used for caching image urls.
+struct ImageIdForNetworkType {
+  ImageIdForNetworkType(IconType icon_type,
+                        const std::string& network_type,
+                        float scale_factor) :
+      icon_type(icon_type),
+      network_type(network_type),
+      scale_factor(scale_factor) {}
+  bool operator<(const ImageIdForNetworkType& other) const {
+    if (icon_type != other.icon_type)
+      return icon_type < other.icon_type;
+    if (network_type != other.network_type)
+      return network_type < other.network_type;
+    return scale_factor < other.scale_factor;
+  }
+  IconType icon_type;
+  std::string network_type;
+  float scale_factor;
+};
+
+typedef std::map<ImageIdForNetworkType, std::string> ImageIdUrlMap;
+
 bool IconTypeIsDark(IconType icon_type) {
   return (icon_type != ICON_TYPE_TRAY);
 }
 
 bool IconTypeHasVPNBadge(IconType icon_type) {
   return (icon_type != ICON_TYPE_LIST);
 }
 
 int NumImagesForType(ImageType type) {
   return (type == BARS) ? kNumBarsImages : kNumArcsImages;
@@ skipping 29 matching lines @@
   int num_images = NumImagesForType(image_type);
   if (index < 0 || index >= num_images)
     return gfx::ImageSkia();
   gfx::ImageSkia* images = BaseImageForType(image_type, icon_type);
   int width = images->width();
   int height = images->height() / num_images;
   return gfx::ImageSkiaOperations::ExtractSubset(*images,
       gfx::Rect(0, index * height, width, height));
 }
 
-const gfx::ImageSkia GetConnectedImage(const std::string& type,
-                                       IconType icon_type) {
-  if (type == shill::kTypeVPN) {
+const gfx::ImageSkia GetConnectedImage(IconType icon_type,
+                                       const std::string& network_type) {
+  if (network_type == shill::kTypeVPN) {
     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_AURA_UBER_TRAY_NETWORK_VPN);
   }
-  ImageType image_type = ImageTypeForNetworkType(type);
+  ImageType image_type = ImageTypeForNetworkType(network_type);
   const int connected_index = NumImagesForType(image_type) - 1;
   return GetImageForIndex(image_type, icon_type, connected_index);
 }
 
-const gfx::ImageSkia GetDisconnectedImage(const std::string& type,
-                                          IconType icon_type) {
-  if (type == shill::kTypeVPN) {
+const gfx::ImageSkia GetDisconnectedImage(IconType icon_type,
+                                          const std::string& network_type) {
+  if (network_type == shill::kTypeVPN) {
     // Note: same as connected image, shouldn't normally be seen.
     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_AURA_UBER_TRAY_NETWORK_VPN);
   }
-  ImageType image_type = ImageTypeForNetworkType(type);
+  ImageType image_type = ImageTypeForNetworkType(network_type);
   const int disconnected_index = 0;
   return GetImageForIndex(image_type, icon_type, disconnected_index);
 }
 
+const std::string& GetDisconnectedImageUrl(IconType icon_type,
+                                           const std::string& network_type,
+                                           float scale_factor) {
+  static ImageIdUrlMap* s_image_url_map = NULL;
+  if (s_image_url_map == NULL)
+    s_image_url_map = new ImageIdUrlMap;
+
+  ImageIdForNetworkType key(icon_type, network_type, scale_factor);
+  ImageIdUrlMap::iterator iter = s_image_url_map->find(key);
+  if (iter != s_image_url_map->end())
+    return iter->second;
+
+  VLOG(2) << "Generating disconnected bitmap URL for: " << network_type;
+  gfx::ImageSkia image = GetDisconnectedImage(icon_type, network_type);
+  gfx::ImageSkiaRep image_rep = image.GetRepresentation(scale_factor);
+  iter = s_image_url_map->insert(std::make_pair(
+      key, webui::GetBitmapDataUrl(image_rep.sk_bitmap()))).first;
+  return iter->second;
+}
+
 gfx::ImageSkia* ConnectingWirelessImage(ImageType image_type,
                                         IconType icon_type,
                                         double animation) {
   static gfx::ImageSkia* s_bars_images_dark[kNumBarsImages - 1];
   static gfx::ImageSkia* s_bars_images_light[kNumBarsImages - 1];
   static gfx::ImageSkia* s_arcs_images_dark[kNumArcsImages - 1];
   static gfx::ImageSkia* s_arcs_images_light[kNumArcsImages - 1];
   int image_count = NumImagesForType(image_type) - 1;
   int index = animation * nextafter(static_cast<float>(image_count), 0);
   index = std::max(std::min(index, image_count - 1), 0);
@@ skipping 160 matching lines @@
     badges.bottom_left = ConnectingVpnBadge(animation);
     return gfx::ImageSkia(
         new NetworkIconImageSource(icon, badges), icon.size());
   } else {
     gfx::ImageSkia* icon = ConnectingVpnImage(animation);
     return gfx::ImageSkia(
         new NetworkIconImageSource(*icon, Badges()), icon->size());
   }
 }
 
-gfx::ImageSkia GetConnectingImage(const std::string& network_type,
-                                  IconType icon_type) {
+gfx::ImageSkia GetConnectingImage(IconType icon_type,
+                                  const std::string& network_type) {
   if (network_type == shill::kTypeVPN)
     return GetConnectingVpnImage(icon_type);
 
   ImageType image_type = ImageTypeForNetworkType(network_type);
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
   gfx::ImageSkia* icon = ConnectingWirelessImage(
       image_type, icon_type, animation);
   return gfx::ImageSkia(
       new NetworkIconImageSource(*icon, Badges()), icon->size());
 }
 
+std::string GetConnectingImageUrl(IconType icon_type,
+                                  const std::string& network_type,
+                                  float scale_factor) {
+  // Caching the connecting image is complicated and we will never draw more
+  // than a few per frame, so just generate the image url each time.
+  gfx::ImageSkia image = GetConnectingImage(icon_type, network_type);
+  gfx::ImageSkiaRep image_rep = image.GetRepresentation(scale_factor);
+  return webui::GetBitmapDataUrl(image_rep.sk_bitmap());
+}
+
 }  // namespace
 
 //------------------------------------------------------------------------------
 // NetworkIconImpl
 
-NetworkIconImpl::NetworkIconImpl(IconType icon_type)
-    : icon_type_(icon_type),
+NetworkIconImpl::NetworkIconImpl(const std::string& path, IconType icon_type)
+    : network_path_(path),
+      icon_type_(icon_type),
       strength_index_(-1),
       technology_badge_(NULL),
       vpn_badge_(NULL),
       behind_captive_portal_(false) {
   // Default image
-  image_ = GetDisconnectedImage(shill::kTypeWifi, icon_type);
+  image_ = GetDisconnectedImage(icon_type, shill::kTypeWifi);
 }
 
 void NetworkIconImpl::Update(const NetworkState* network) {
   DCHECK(network);
   // Determine whether or not we need to update the icon.
   bool dirty = image_.isNull();
 
   // If the network state has changed, the icon needs updating.
   if (state_ != network->connection_state()) {
     state_ = network->connection_state();
@@ skipping 118 matching lines @@
   }
 }
 
 void NetworkIconImpl::GenerateImage(const NetworkState* network) {
   DCHECK(network);
   gfx::ImageSkia icon = GetIcon(network, icon_type_, strength_index_);
   Badges badges;
   GetBadges(network, &badges);
   image_ = gfx::ImageSkia(
       new NetworkIconImageSource(icon, badges), icon.size());
+  image_urls_.clear();
 }
 
-//------------------------------------------------------------------------------
-// Public interface
+const std::string& NetworkIconImpl::GetImageUrl(float scale_factor) {
+  ImageUrlMap::iterator iter = image_urls_.find(scale_factor);
+  if (iter != image_urls_.end())
+    return iter->second;
 
-gfx::ImageSkia GetImageForNetwork(const NetworkState* network,
-                                  IconType icon_type) {
-  DCHECK(network);
-  // Handle connecting icons.
-  if (network->IsConnectingState())
-    return GetConnectingImage(network->type(), icon_type);
+  VLOG(2) << "Generating bitmap URL for: " << network_path_;
+  gfx::ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
+  iter = image_urls_.insert(std::make_pair(
+      scale_factor, webui::GetBitmapDataUrl(image_rep.sk_bitmap()))).first;
+  return iter->second;
+}
 
+namespace {
+
+NetworkIconImpl* FindAndUpdateImageImpl(const NetworkState* network,
+                                        IconType icon_type) {
   // Find or add the icon.
   NetworkIconMap* icon_map = GetIconMap(icon_type);
   NetworkIconImpl* icon;
   NetworkIconMap::iterator iter = icon_map->find(network->path());
   if (iter == icon_map->end()) {
-    icon = new NetworkIconImpl(icon_type);
+    icon = new NetworkIconImpl(network->path(), icon_type);
     icon_map->insert(std::make_pair(network->path(), icon));
   } else {
     icon = iter->second;
   }
 
   // Update and return the icon's image.
   icon->Update(network);
+  return icon;
+}
+
+}  // namespace
+
+//------------------------------------------------------------------------------
+// Public interface
+
+gfx::ImageSkia GetImageForNetwork(const NetworkState* network,
+                                  IconType icon_type) {
+  DCHECK(network);
+  // Handle connecting icons.
+  if (network->IsConnectingState())
+    return GetConnectingImage(icon_type, network->type());
+
+  NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
   return icon->image();
 }
 
+std::string GetImageUrlForNetwork(const NetworkState* network,
+                                  IconType icon_type,
+                                  float scale_factor) {
+  DCHECK(network);
+  // Handle connecting icons.
+  if (network->IsConnectingState())
+    return GetConnectingImageUrl(icon_type, network->type(), scale_factor);
+
+  NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
+  return icon->GetImageUrl(scale_factor);
+}
+
 gfx::ImageSkia GetImageForConnectedNetwork(IconType icon_type,
                                            const std::string& network_type) {
-  return GetConnectedImage(network_type, icon_type);
+  return GetConnectedImage(icon_type, network_type);
 }
 
 gfx::ImageSkia GetImageForConnectingNetwork(IconType icon_type,
                                             const std::string& network_type) {
-  return GetConnectingImage(network_type, icon_type);
+  return GetConnectingImage(icon_type, network_type);
 }
 
 gfx::ImageSkia GetImageForDisconnectedNetwork(IconType icon_type,
                                               const std::string& network_type) {
-  return GetDisconnectedImage(network_type, icon_type);
+  return GetDisconnectedImage(icon_type, network_type);
+}
+
+std::string GetImageUrlForDisconnectedNetwork(IconType icon_type,
+                                              const std::string& network_type,
+                                              float scale_factor) {
+  return GetDisconnectedImageUrl(icon_type, network_type, scale_factor);
 }
 
 base::string16 GetLabelForNetwork(const chromeos::NetworkState* network,
                                   IconType icon_type) {
   DCHECK(network);
   std::string activation_state = network->activation_state();
   if (icon_type == ICON_TYPE_LIST) {
     // Show "<network>: [Connecting|Activating]..."
     if (network->IsConnectingState()) {
       return l10n_util::GetStringFUTF16(
@@ skipping 141 matching lines @@
        iter != networks.end(); ++iter) {
     network_paths.insert((*iter)->path());
   }
   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
   PurgeIconMap(ICON_TYPE_LIST, network_paths);
 }
 
 }  // namespace network_icon
 }  // namespace ash