ui/chromeos/network/network_icon.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/chromeos/network/network_icon.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chromeos/network/device_state.h"
   9 #include "chromeos/network/network_connection_handler.h"
  10 #include "chromeos/network/network_state.h"
  11 #include "chromeos/network/network_state_handler.h"
  12 #include "chromeos/network/portal_detector/network_portal_detector.h"
  13 #include "grit/ui_chromeos_resources.h"
  14 #include "grit/ui_chromeos_strings.h"
  15 #include "third_party/cros_system_api/dbus/service_constants.h"
  16 #include "ui/base/l10n/l10n_util.h"
  17 #include "ui/base/resource/resource_bundle.h"
  18 #include "ui/base/webui/web_ui_util.h"
  19 #include "ui/chromeos/network/network_icon_animation.h"
  20 #include "ui/chromeos/network/network_icon_animation_observer.h"
  21 #include "ui/gfx/canvas.h"
  22 #include "ui/gfx/image/image_skia_operations.h"
  23 #include "ui/gfx/image/image_skia_source.h"
  24 #include "ui/gfx/rect.h"
  25 #include "ui/gfx/size_conversions.h"
  26
  27 using chromeos::DeviceState;
  28 using chromeos::NetworkConnectionHandler;
  29 using chromeos::NetworkHandler;
  30 using chromeos::NetworkPortalDetector;
  31 using chromeos::NetworkState;
  32 using chromeos::NetworkStateHandler;
  33 using chromeos::NetworkTypePattern;
  34
  35 namespace ui {
  36 namespace network_icon {
  37
  38 namespace {
  39
  40 //------------------------------------------------------------------------------
  41 // Struct to pass icon badges to NetworkIconImageSource.
  42 struct Badges {
  43   Badges()
  44       : top_left(NULL),
  45         top_right(NULL),
  46         bottom_left(NULL),
  47         bottom_right(NULL) {
  48   }
  49   const gfx::ImageSkia* top_left;
  50   const gfx::ImageSkia* top_right;
  51   const gfx::ImageSkia* bottom_left;
  52   const gfx::ImageSkia* bottom_right;
  53 };
  54
  55 //------------------------------------------------------------------------------
  56 // class used for maintaining a map of network state and images.
  57 class NetworkIconImpl {
  58  public:
  59   NetworkIconImpl(const std::string& path, IconType icon_type);
  60
  61   // Determines whether or not the associated network might be dirty and if so
  62   // updates and generates the icon. Does nothing if network no longer exists.
  63   void Update(const chromeos::NetworkState* network);
  64
  65   // Returns the cached image url for |image_| based on |scale_factor|.
  66   const std::string& GetImageUrl(float scale_factor);
  67
  68   const gfx::ImageSkia& image() const { return image_; }
  69
  70  private:
  71   typedef std::map<float, std::string> ImageUrlMap;
  72
  73   // Updates |strength_index_| for wireless networks. Returns true if changed.
  74   bool UpdateWirelessStrengthIndex(const chromeos::NetworkState* network);
  75
  76   // Updates the local state for cellular networks. Returns true if changed.
  77   bool UpdateCellularState(const chromeos::NetworkState* network);
  78
  79   // Updates the portal state for wireless networks. Returns true if changed.
  80   bool UpdatePortalState(const chromeos::NetworkState* network);
  81
  82   // Updates the VPN badge. Returns true if changed.
  83   bool UpdateVPNBadge();
  84
  85   // Gets |badges| based on |network| and the current state.
  86   void GetBadges(const NetworkState* network, Badges* badges);
  87
  88   // Gets the appropriate icon and badges and composites the image.
  89   void GenerateImage(const chromeos::NetworkState* network);
  90
  91   // Network path, used for debugging.
  92   std::string network_path_;
  93
  94   // Defines color theme and VPN badging
  95   const IconType icon_type_;
  96
  97   // Cached state of the network when the icon was last generated.
  98   std::string state_;
  99
 100   // Cached strength index of the network when the icon was last generated.
 101   int strength_index_;
 102
 103   // Cached technology badge for the network when the icon was last generated.
 104   const gfx::ImageSkia* technology_badge_;
 105
 106   // Cached vpn badge for the network when the icon was last generated.
 107   const gfx::ImageSkia* vpn_badge_;
 108
 109   // Cached roaming state of the network when the icon was last generated.
 110   std::string roaming_state_;
 111
 112   // Cached portal state of the network when the icon was last generated.
 113   bool behind_captive_portal_;
 114
 115   // Generated icon image.
 116   gfx::ImageSkia image_;
 117
 118   // Map of cached image urls by scale factor. Cleared whenever image_ is
 119   // generated.
 120   ImageUrlMap image_urls_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(NetworkIconImpl);
 123 };
 124
 125 //------------------------------------------------------------------------------
 126 // Maintain a static (global) icon map. Note: Icons are never destroyed;
 127 // it is assumed that a finite and reasonable number of network icons will be
 128 // created during a session.
 129
 130 typedef std::map<std::string, NetworkIconImpl*> NetworkIconMap;
 131
 132 NetworkIconMap* GetIconMapInstance(IconType icon_type, bool create) {
 133   typedef std::map<IconType, NetworkIconMap*> IconTypeMap;
 134   static IconTypeMap* s_icon_map = NULL;
 135   if (s_icon_map == NULL) {
 136     if (!create)
 137       return NULL;
 138     s_icon_map = new IconTypeMap;
 139   }
 140   if (s_icon_map->count(icon_type) == 0) {
 141     if (!create)
 142       return NULL;
 143     (*s_icon_map)[icon_type] = new NetworkIconMap;
 144   }
 145   return (*s_icon_map)[icon_type];
 146 }
 147
 148 NetworkIconMap* GetIconMap(IconType icon_type) {
 149   return GetIconMapInstance(icon_type, true);
 150 }
 151
 152 void PurgeIconMap(IconType icon_type,
 153                   const std::set<std::string>& network_paths) {
 154   NetworkIconMap* icon_map = GetIconMapInstance(icon_type, false);
 155   if (!icon_map)
 156     return;
 157   for (NetworkIconMap::iterator loop_iter = icon_map->begin();
 158        loop_iter != icon_map->end(); ) {
 159     NetworkIconMap::iterator cur_iter = loop_iter++;
 160     if (network_paths.count(cur_iter->first) == 0) {
 161       delete cur_iter->second;
 162       icon_map->erase(cur_iter);
 163     }
 164   }
 165 }
 166
 167 //------------------------------------------------------------------------------
 168 // Utilities for generating icon images.
 169
 170 // 'NONE' will default to ARCS behavior where appropriate (e.g. no network or
 171 // if a new type gets added).
 172 enum ImageType {
 173   ARCS,
 174   BARS,
 175   NONE
 176 };
 177
 178 // Amount to fade icons while connecting.
 179 const double kConnectingImageAlpha = 0.5;
 180
 181 // Images for strength bars for wired networks.
 182 const int kNumBarsImages = 5;
 183
 184 // Imagaes for strength arcs for wireless networks.
 185 const int kNumArcsImages = 5;
 186
 187 // Number of discrete images to use for alpha fade animation
 188 const int kNumFadeImages = 10;
 189
 190 //------------------------------------------------------------------------------
 191 // Classes for generating scaled images.
 192
 193 const SkBitmap GetEmptyBitmap(const gfx::Size pixel_size) {
 194   typedef std::pair<int, int> SizeKey;
 195   typedef std::map<SizeKey, SkBitmap> SizeBitmapMap;
 196   static SizeBitmapMap* s_empty_bitmaps = new SizeBitmapMap;
 197
 198   SizeKey key(pixel_size.width(), pixel_size.height());
 199
 200   SizeBitmapMap::iterator iter = s_empty_bitmaps->find(key);
 201   if (iter != s_empty_bitmaps->end())
 202     return iter->second;
 203
 204   SkBitmap empty;
 205   empty.allocN32Pixels(key.first, key.second);
 206   empty.eraseARGB(0, 0, 0, 0);
 207   (*s_empty_bitmaps)[key] = empty;
 208   return empty;
 209 }
 210
 211 class EmptyImageSource: public gfx::ImageSkiaSource {
 212  public:
 213   explicit EmptyImageSource(const gfx::Size& size)
 214       : size_(size) {
 215   }
 216
 217   virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
 218     gfx::Size pixel_size = gfx::ToFlooredSize(gfx::ScaleSize(size_, scale));
 219     SkBitmap empty_bitmap = GetEmptyBitmap(pixel_size);
 220     return gfx::ImageSkiaRep(empty_bitmap, scale);
 221   }
 222
 223  private:
 224   const gfx::Size size_;
 225
 226   DISALLOW_COPY_AND_ASSIGN(EmptyImageSource);
 227 };
 228
 229 // This defines how we assemble a network icon.
 230 class NetworkIconImageSource : public gfx::ImageSkiaSource {
 231  public:
 232   NetworkIconImageSource(const gfx::ImageSkia& icon, const Badges& badges)
 233       : icon_(icon),
 234         badges_(badges) {
 235   }
 236   virtual ~NetworkIconImageSource() {}
 237
 238   // TODO(pkotwicz): Figure out what to do when a new image resolution becomes
 239   // available.
 240   virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
 241     gfx::ImageSkiaRep icon_rep = icon_.GetRepresentation(scale);
 242     if (icon_rep.is_null())
 243       return gfx::ImageSkiaRep();
 244     gfx::Canvas canvas(icon_rep, false);
 245     if (badges_.top_left)
 246       canvas.DrawImageInt(*badges_.top_left, 0, 0);
 247     if (badges_.top_right)
 248       canvas.DrawImageInt(*badges_.top_right,
 249                           icon_.width() - badges_.top_right->width(), 0);
 250     if (badges_.bottom_left) {
 251       canvas.DrawImageInt(*badges_.bottom_left,
 252                           0, icon_.height() - badges_.bottom_left->height());
 253     }
 254     if (badges_.bottom_right) {
 255       canvas.DrawImageInt(*badges_.bottom_right,
 256                           icon_.width() - badges_.bottom_right->width(),
 257                           icon_.height() - badges_.bottom_right->height());
 258     }
 259     return canvas.ExtractImageRep();
 260   }
 261
 262  private:
 263   const gfx::ImageSkia icon_;
 264   const Badges badges_;
 265
 266   DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSource);
 267 };
 268
 269 //------------------------------------------------------------------------------
 270 // Utilities for extracting icon images.
 271
 272 // A struct used for caching image urls.
 273 struct ImageIdForNetworkType {
 274   ImageIdForNetworkType(IconType icon_type,
 275                         const std::string& network_type,
 276                         float scale_factor) :
 277       icon_type(icon_type),
 278       network_type(network_type),
 279       scale_factor(scale_factor) {}
 280   bool operator<(const ImageIdForNetworkType& other) const {
 281     if (icon_type != other.icon_type)
 282       return icon_type < other.icon_type;
 283     if (network_type != other.network_type)
 284       return network_type < other.network_type;
 285     return scale_factor < other.scale_factor;
 286   }
 287   IconType icon_type;
 288   std::string network_type;
 289   float scale_factor;
 290 };
 291
 292 typedef std::map<ImageIdForNetworkType, std::string> ImageIdUrlMap;
 293
 294 bool IconTypeIsDark(IconType icon_type) {
 295   return (icon_type != ICON_TYPE_TRAY);
 296 }
 297
 298 bool IconTypeHasVPNBadge(IconType icon_type) {
 299   return (icon_type != ICON_TYPE_LIST);
 300 }
 301
 302 int NumImagesForType(ImageType type) {
 303   return (type == BARS) ? kNumBarsImages : kNumArcsImages;
 304 }
 305
 306 gfx::ImageSkia* BaseImageForType(ImageType image_type, IconType icon_type) {
 307   gfx::ImageSkia* image;
 308   if (image_type == BARS) {
 309     image =  ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 310         IconTypeIsDark(icon_type) ?
 311         IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK :
 312         IDR_AURA_UBER_TRAY_NETWORK_BARS_LIGHT);
 313   } else {
 314     image =  ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 315         IconTypeIsDark(icon_type) ?
 316         IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK :
 317         IDR_AURA_UBER_TRAY_NETWORK_ARCS_LIGHT);
 318   }
 319   return image;
 320 }
 321
 322 ImageType ImageTypeForNetworkType(const std::string& type) {
 323   if (type == shill::kTypeWifi)
 324     return ARCS;
 325   else if (type == shill::kTypeCellular || type == shill::kTypeWimax)
 326     return BARS;
 327   return NONE;
 328 }
 329
 330 gfx::ImageSkia GetImageForIndex(ImageType image_type,
 331                                 IconType icon_type,
 332                                 int index) {
 333   int num_images = NumImagesForType(image_type);
 334   if (index < 0 || index >= num_images)
 335     return gfx::ImageSkia();
 336   gfx::ImageSkia* images = BaseImageForType(image_type, icon_type);
 337   int width = images->width();
 338   int height = images->height() / num_images;
 339   return gfx::ImageSkiaOperations::ExtractSubset(*images,
 340       gfx::Rect(0, index * height, width, height));
 341 }
 342
 343 const gfx::ImageSkia GetConnectedImage(IconType icon_type,
 344                                        const std::string& network_type) {
 345   if (network_type == shill::kTypeVPN) {
 346     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 347         IDR_AURA_UBER_TRAY_NETWORK_VPN);
 348   }
 349   ImageType image_type = ImageTypeForNetworkType(network_type);
 350   const int connected_index = NumImagesForType(image_type) - 1;
 351   return GetImageForIndex(image_type, icon_type, connected_index);
 352 }
 353
 354 const gfx::ImageSkia GetDisconnectedImage(IconType icon_type,
 355                                           const std::string& network_type) {
 356   if (network_type == shill::kTypeVPN) {
 357     // Note: same as connected image, shouldn't normally be seen.
 358     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 359         IDR_AURA_UBER_TRAY_NETWORK_VPN);
 360   }
 361   ImageType image_type = ImageTypeForNetworkType(network_type);
 362   const int disconnected_index = 0;
 363   return GetImageForIndex(image_type, icon_type, disconnected_index);
 364 }
 365
 366 gfx::ImageSkia* ConnectingWirelessImage(ImageType image_type,
 367                                         IconType icon_type,
 368                                         double animation) {
 369   static gfx::ImageSkia* s_bars_images_dark[kNumBarsImages - 1];
 370   static gfx::ImageSkia* s_bars_images_light[kNumBarsImages - 1];
 371   static gfx::ImageSkia* s_arcs_images_dark[kNumArcsImages - 1];
 372   static gfx::ImageSkia* s_arcs_images_light[kNumArcsImages - 1];
 373   int image_count = NumImagesForType(image_type) - 1;
 374   int index = animation * nextafter(static_cast<float>(image_count), 0);
 375   index = std::max(std::min(index, image_count - 1), 0);
 376   gfx::ImageSkia** images;
 377   bool dark = IconTypeIsDark(icon_type);
 378   if (image_type == BARS)
 379     images = dark ? s_bars_images_dark : s_bars_images_light;
 380   else
 381     images = dark ? s_arcs_images_dark : s_arcs_images_light;
 382   if (!images[index]) {
 383     // Lazily cache images.
 384     gfx::ImageSkia source = GetImageForIndex(image_type, icon_type, index + 1);
 385     images[index] = new gfx::ImageSkia(
 386         gfx::ImageSkiaOperations::CreateBlendedImage(
 387             gfx::ImageSkia(new EmptyImageSource(source.size()), source.size()),
 388             source,
 389             kConnectingImageAlpha));
 390   }
 391   return images[index];
 392 }
 393
 394 gfx::ImageSkia* ConnectingVpnImage(double animation) {
 395   int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
 396   static gfx::ImageSkia* s_vpn_images[kNumFadeImages];
 397   if (!s_vpn_images[index]) {
 398     // Lazily cache images.
 399     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 400     gfx::ImageSkia* icon = rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN);
 401     s_vpn_images[index] = new gfx::ImageSkia(
 402         gfx::ImageSkiaOperations::CreateBlendedImage(
 403             gfx::ImageSkia(new EmptyImageSource(icon->size()), icon->size()),
 404             *icon,
 405             animation));
 406   }
 407   return s_vpn_images[index];
 408 }
 409
 410 gfx::ImageSkia* ConnectingVpnBadge(double animation) {
 411   int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
 412   static gfx::ImageSkia* s_vpn_badges[kNumFadeImages];
 413   if (!s_vpn_badges[index]) {
 414     // Lazily cache images.
 415     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 416     gfx::ImageSkia* icon =
 417         rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);  // For size
 418     gfx::ImageSkia* badge =
 419         rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
 420     s_vpn_badges[index] = new gfx::ImageSkia(
 421         gfx::ImageSkiaOperations::CreateBlendedImage(
 422             gfx::ImageSkia(new EmptyImageSource(icon->size()), icon->size()),
 423             *badge,
 424             animation));
 425   }
 426   return s_vpn_badges[index];
 427 }
 428
 429 int StrengthIndex(int strength, int count) {
 430   // Return an index in the range [1, count-1].
 431   const float findex = (static_cast<float>(strength) / 100.0f) *
 432       nextafter(static_cast<float>(count - 1), 0);
 433   int index = 1 + static_cast<int>(findex);
 434   index = std::max(std::min(index, count - 1), 1);
 435   return index;
 436 }
 437
 438 int GetStrengthIndex(const NetworkState* network) {
 439   ImageType image_type = ImageTypeForNetworkType(network->type());
 440   if (image_type == ARCS)
 441     return StrengthIndex(network->signal_strength(), kNumArcsImages);
 442   else if (image_type == BARS)
 443     return StrengthIndex(network->signal_strength(), kNumBarsImages);
 444   return 0;
 445 }
 446
 447 const gfx::ImageSkia* BadgeForNetworkTechnology(const NetworkState* network,
 448                                                 IconType icon_type) {
 449   const int kUnknownBadgeType = -1;
 450   int id = kUnknownBadgeType;
 451   const std::string& technology = network->network_technology();
 452   if (technology == shill::kNetworkTechnologyEvdo) {
 453     id = IconTypeIsDark(icon_type) ?
 454         IDR_AURA_UBER_TRAY_NETWORK_EVDO_DARK :
 455         IDR_AURA_UBER_TRAY_NETWORK_EVDO_LIGHT;
 456   } else if (technology == shill::kNetworkTechnology1Xrtt) {
 457     id = IDR_AURA_UBER_TRAY_NETWORK_1X;
 458   } else if (technology == shill::kNetworkTechnologyGprs) {
 459     id = IconTypeIsDark(icon_type) ?
 460         IDR_AURA_UBER_TRAY_NETWORK_GPRS_DARK :
 461         IDR_AURA_UBER_TRAY_NETWORK_GPRS_LIGHT;
 462   } else if (technology == shill::kNetworkTechnologyEdge) {
 463     id = IconTypeIsDark(icon_type) ?
 464         IDR_AURA_UBER_TRAY_NETWORK_EDGE_DARK :
 465         IDR_AURA_UBER_TRAY_NETWORK_EDGE_LIGHT;
 466   } else if (technology == shill::kNetworkTechnologyUmts) {
 467     id = IconTypeIsDark(icon_type) ?
 468         IDR_AURA_UBER_TRAY_NETWORK_3G_DARK :
 469         IDR_AURA_UBER_TRAY_NETWORK_3G_LIGHT;
 470   } else if (technology == shill::kNetworkTechnologyHspa) {
 471     id = IconTypeIsDark(icon_type) ?
 472         IDR_AURA_UBER_TRAY_NETWORK_HSPA_DARK :
 473         IDR_AURA_UBER_TRAY_NETWORK_HSPA_LIGHT;
 474   } else if (technology == shill::kNetworkTechnologyHspaPlus) {
 475     id = IconTypeIsDark(icon_type) ?
 476         IDR_AURA_UBER_TRAY_NETWORK_HSPA_PLUS_DARK :
 477         IDR_AURA_UBER_TRAY_NETWORK_HSPA_PLUS_LIGHT;
 478   } else if (technology == shill::kNetworkTechnologyLte) {
 479     id = IconTypeIsDark(icon_type) ?
 480         IDR_AURA_UBER_TRAY_NETWORK_LTE_DARK :
 481         IDR_AURA_UBER_TRAY_NETWORK_LTE_LIGHT;
 482   } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
 483     id = IconTypeIsDark(icon_type) ?
 484         IDR_AURA_UBER_TRAY_NETWORK_LTE_ADVANCED_DARK :
 485         IDR_AURA_UBER_TRAY_NETWORK_LTE_ADVANCED_LIGHT;
 486   } else if (technology == shill::kNetworkTechnologyGsm) {
 487     id = IconTypeIsDark(icon_type) ?
 488         IDR_AURA_UBER_TRAY_NETWORK_GPRS_DARK :
 489         IDR_AURA_UBER_TRAY_NETWORK_GPRS_LIGHT;
 490   }
 491   if (id == kUnknownBadgeType)
 492     return NULL;
 493   else
 494     return ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
 495 }
 496
 497 const gfx::ImageSkia* BadgeForVPN(IconType icon_type) {
 498   return ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 499       IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
 500 }
 501
 502 gfx::ImageSkia GetIcon(const NetworkState* network,
 503                        IconType icon_type,
 504                        int strength_index) {
 505   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 506   if (network->Matches(NetworkTypePattern::Ethernet())) {
 507     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
 508   } else if (network->Matches(NetworkTypePattern::Wireless())) {
 509     DCHECK(strength_index > 0);
 510     return GetImageForIndex(
 511         ImageTypeForNetworkType(network->type()), icon_type, strength_index);
 512   } else if (network->Matches(NetworkTypePattern::VPN())) {
 513     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN);
 514   } else {
 515     LOG(WARNING) << "Request for icon for unsupported type: "
 516                  << network->type();
 517     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
 518   }
 519 }
 520
 521 //------------------------------------------------------------------------------
 522 // Get connecting images
 523
 524 gfx::ImageSkia GetConnectingVpnImage(IconType icon_type) {
 525   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 526   const NetworkState* connected_network = NULL;
 527   if (icon_type == ICON_TYPE_TRAY) {
 528     connected_network =
 529         handler->ConnectedNetworkByType(NetworkTypePattern::NonVirtual());
 530   }
 531   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 532
 533   if (connected_network) {
 534     gfx::ImageSkia icon = GetImageForNetwork(connected_network, icon_type);
 535     Badges badges;
 536     badges.bottom_left = ConnectingVpnBadge(animation);
 537     return gfx::ImageSkia(
 538         new NetworkIconImageSource(icon, badges), icon.size());
 539   } else {
 540     gfx::ImageSkia* icon = ConnectingVpnImage(animation);
 541     return gfx::ImageSkia(
 542         new NetworkIconImageSource(*icon, Badges()), icon->size());
 543   }
 544 }
 545
 546 gfx::ImageSkia GetConnectingImage(IconType icon_type,
 547                                   const std::string& network_type) {
 548   if (network_type == shill::kTypeVPN)
 549     return GetConnectingVpnImage(icon_type);
 550
 551   ImageType image_type = ImageTypeForNetworkType(network_type);
 552   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 553
 554   gfx::ImageSkia* icon = ConnectingWirelessImage(
 555       image_type, icon_type, animation);
 556   return gfx::ImageSkia(
 557       new NetworkIconImageSource(*icon, Badges()), icon->size());
 558 }
 559
 560 std::string GetConnectingImageUrl(IconType icon_type,
 561                                   const std::string& network_type,
 562                                   float scale_factor) {
 563   // Caching the connecting image is complicated and we will never draw more
 564   // than a few per frame, so just generate the image url each time.
 565   gfx::ImageSkia image = GetConnectingImage(icon_type, network_type);
 566   gfx::ImageSkiaRep image_rep = image.GetRepresentation(scale_factor);
 567   return webui::GetBitmapDataUrl(image_rep.sk_bitmap());
 568 }
 569
 570 }  // namespace
 571
 572 //------------------------------------------------------------------------------
 573 // NetworkIconImpl
 574
 575 NetworkIconImpl::NetworkIconImpl(const std::string& path, IconType icon_type)
 576     : network_path_(path),
 577       icon_type_(icon_type),
 578       strength_index_(-1),
 579       technology_badge_(NULL),
 580       vpn_badge_(NULL),
 581       behind_captive_portal_(false) {
 582   // Default image
 583   image_ = GetDisconnectedImage(icon_type, shill::kTypeWifi);
 584 }
 585
 586 void NetworkIconImpl::Update(const NetworkState* network) {
 587   DCHECK(network);
 588   // Determine whether or not we need to update the icon.
 589   bool dirty = image_.isNull();
 590
 591   // If the network state has changed, the icon needs updating.
 592   if (state_ != network->connection_state()) {
 593     state_ = network->connection_state();
 594     dirty = true;
 595   }
 596
 597   dirty |= UpdatePortalState(network);
 598
 599   if (network->Matches(NetworkTypePattern::Wireless())) {
 600     dirty |= UpdateWirelessStrengthIndex(network);
 601   }
 602
 603   if (network->Matches(NetworkTypePattern::Cellular()))
 604     dirty |= UpdateCellularState(network);
 605
 606   if (IconTypeHasVPNBadge(icon_type_) &&
 607       network->Matches(NetworkTypePattern::NonVirtual())) {
 608     dirty |= UpdateVPNBadge();
 609   }
 610
 611   if (dirty) {
 612     // Set the icon and badges based on the network and generate the image.
 613     GenerateImage(network);
 614   }
 615 }
 616
 617 bool NetworkIconImpl::UpdateWirelessStrengthIndex(const NetworkState* network) {
 618   int index = GetStrengthIndex(network);
 619   if (index != strength_index_) {
 620     strength_index_ = index;
 621     return true;
 622   }
 623   return false;
 624 }
 625
 626 bool NetworkIconImpl::UpdateCellularState(const NetworkState* network) {
 627   bool dirty = false;
 628   const gfx::ImageSkia* technology_badge =
 629       BadgeForNetworkTechnology(network, icon_type_);
 630   if (technology_badge != technology_badge_) {
 631     technology_badge_ = technology_badge;
 632     dirty = true;
 633   }
 634   std::string roaming_state = network->roaming();
 635   if (roaming_state != roaming_state_) {
 636     roaming_state_ = roaming_state;
 637     dirty = true;
 638   }
 639   return dirty;
 640 }
 641
 642 bool NetworkIconImpl::UpdatePortalState(const NetworkState* network) {
 643   bool behind_captive_portal = false;
 644   if (network && NetworkPortalDetector::IsInitialized()) {
 645     NetworkPortalDetector::CaptivePortalState state =
 646         NetworkPortalDetector::Get()->GetCaptivePortalState(network->guid());
 647     behind_captive_portal =
 648         state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
 649   }
 650
 651   if (behind_captive_portal == behind_captive_portal_)
 652     return false;
 653   behind_captive_portal_ = behind_captive_portal;
 654   return true;
 655 }
 656
 657 bool NetworkIconImpl::UpdateVPNBadge() {
 658   const NetworkState* vpn = NetworkHandler::Get()->network_state_handler()->
 659       ConnectedNetworkByType(NetworkTypePattern::VPN());
 660   if (vpn && vpn_badge_ == NULL) {
 661     vpn_badge_ = BadgeForVPN(icon_type_);
 662     return true;
 663   } else if (!vpn && vpn_badge_ != NULL) {
 664     vpn_badge_ = NULL;
 665     return true;
 666   }
 667   return false;
 668 }
 669
 670 void NetworkIconImpl::GetBadges(const NetworkState* network, Badges* badges) {
 671   DCHECK(network);
 672   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 673   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 674
 675   const std::string& type = network->type();
 676   if (type == shill::kTypeWifi) {
 677     if (network->security() != shill::kSecurityNone &&
 678         IconTypeIsDark(icon_type_)) {
 679       badges->bottom_right = rb.GetImageSkiaNamed(
 680           IDR_AURA_UBER_TRAY_NETWORK_SECURE_DARK);
 681     }
 682   } else if (type == shill::kTypeWimax) {
 683     technology_badge_ = rb.GetImageSkiaNamed(
 684         IconTypeIsDark(icon_type_) ?
 685         IDR_AURA_UBER_TRAY_NETWORK_4G_DARK :
 686         IDR_AURA_UBER_TRAY_NETWORK_4G_LIGHT);
 687   } else if (type == shill::kTypeCellular) {
 688     if (network->roaming() == shill::kRoamingStateRoaming) {
 689       // For networks that are always in roaming don't show roaming badge.
 690       const DeviceState* device =
 691           handler->GetDeviceState(network->device_path());
 692       LOG_IF(WARNING, !device) << "Could not find device state for "
 693                                << network->device_path();
 694       if (!device || !device->provider_requires_roaming()) {
 695         badges->bottom_right = rb.GetImageSkiaNamed(
 696             IconTypeIsDark(icon_type_) ?
 697             IDR_AURA_UBER_TRAY_NETWORK_ROAMING_DARK :
 698             IDR_AURA_UBER_TRAY_NETWORK_ROAMING_LIGHT);
 699       }
 700     }
 701   }
 702   if (!network->IsConnectingState()) {
 703     badges->top_left = technology_badge_;
 704     badges->bottom_left = vpn_badge_;
 705   }
 706
 707   if (behind_captive_portal_) {
 708     gfx::ImageSkia* badge = rb.GetImageSkiaNamed(
 709        IconTypeIsDark(icon_type_) ?
 710        IDR_AURA_UBER_TRAY_NETWORK_PORTAL_DARK :
 711        IDR_AURA_UBER_TRAY_NETWORK_PORTAL_LIGHT);
 712     badges->bottom_right = badge;
 713   }
 714 }
 715
 716 void NetworkIconImpl::GenerateImage(const NetworkState* network) {
 717   DCHECK(network);
 718   gfx::ImageSkia icon = GetIcon(network, icon_type_, strength_index_);
 719   Badges badges;
 720   GetBadges(network, &badges);
 721   image_ = gfx::ImageSkia(
 722       new NetworkIconImageSource(icon, badges), icon.size());
 723   image_urls_.clear();
 724 }
 725
 726 const std::string& NetworkIconImpl::GetImageUrl(float scale_factor) {
 727   ImageUrlMap::iterator iter = image_urls_.find(scale_factor);
 728   if (iter != image_urls_.end())
 729     return iter->second;
 730
 731   VLOG(2) << "Generating bitmap URL for: " << network_path_;
 732   gfx::ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
 733   iter = image_urls_.insert(std::make_pair(
 734       scale_factor, webui::GetBitmapDataUrl(image_rep.sk_bitmap()))).first;
 735   return iter->second;
 736 }
 737
 738 namespace {
 739
 740 NetworkIconImpl* FindAndUpdateImageImpl(const NetworkState* network,
 741                                         IconType icon_type) {
 742   // Find or add the icon.
 743   NetworkIconMap* icon_map = GetIconMap(icon_type);
 744   NetworkIconImpl* icon;
 745   NetworkIconMap::iterator iter = icon_map->find(network->path());
 746   if (iter == icon_map->end()) {
 747     icon = new NetworkIconImpl(network->path(), icon_type);
 748     icon_map->insert(std::make_pair(network->path(), icon));
 749   } else {
 750     icon = iter->second;
 751   }
 752
 753   // Update and return the icon's image.
 754   icon->Update(network);
 755   return icon;
 756 }
 757
 758 }  // namespace
 759
 760 //------------------------------------------------------------------------------
 761 // Public interface
 762
 763 gfx::ImageSkia GetImageForNetwork(const NetworkState* network,
 764                                   IconType icon_type) {
 765   DCHECK(network);
 766   if (!network->visible())
 767     return GetDisconnectedImage(icon_type, network->type());
 768
 769   if (network->IsConnectingState())
 770     return GetConnectingImage(icon_type, network->type());
 771
 772   NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
 773   return icon->image();
 774 }
 775
 776 std::string GetImageUrlForNetwork(const NetworkState* network,
 777                                   IconType icon_type,
 778                                   float scale_factor) {
 779   DCHECK(network);
 780   // Handle connecting icons.
 781   if (network->IsConnectingState())
 782     return GetConnectingImageUrl(icon_type, network->type(), scale_factor);
 783
 784   NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
 785   return icon->GetImageUrl(scale_factor);
 786 }
 787
 788 gfx::ImageSkia GetImageForConnectedNetwork(IconType icon_type,
 789                                            const std::string& network_type) {
 790   return GetConnectedImage(icon_type, network_type);
 791 }
 792
 793 gfx::ImageSkia GetImageForConnectingNetwork(IconType icon_type,
 794                                             const std::string& network_type) {
 795   return GetConnectingImage(icon_type, network_type);
 796 }
 797
 798 gfx::ImageSkia GetImageForDisconnectedNetwork(IconType icon_type,
 799                                               const std::string& network_type) {
 800   return GetDisconnectedImage(icon_type, network_type);
 801 }
 802
 803 base::string16 GetLabelForNetwork(const chromeos::NetworkState* network,
 804                                   IconType icon_type) {
 805   DCHECK(network);
 806   std::string activation_state = network->activation_state();
 807   if (icon_type == ICON_TYPE_LIST) {
 808     // Show "<network>: [Connecting|Activating]..."
 809     if (network->IsConnectingState()) {
 810       return l10n_util::GetStringFUTF16(
 811           IDS_ASH_STATUS_TRAY_NETWORK_LIST_CONNECTING,
 812           base::UTF8ToUTF16(network->name()));
 813     }
 814     if (activation_state == shill::kActivationStateActivating) {
 815       return l10n_util::GetStringFUTF16(
 816           IDS_ASH_STATUS_TRAY_NETWORK_LIST_ACTIVATING,
 817           base::UTF8ToUTF16(network->name()));
 818     }
 819     // Show "Activate <network>" in list view only.
 820     if (activation_state == shill::kActivationStateNotActivated ||
 821         activation_state == shill::kActivationStatePartiallyActivated) {
 822       return l10n_util::GetStringFUTF16(
 823           IDS_ASH_STATUS_TRAY_NETWORK_LIST_ACTIVATE,
 824           base::UTF8ToUTF16(network->name()));
 825     }
 826   } else {
 827     // Show "[Connected to|Connecting to|Activating] <network>" (non-list view).
 828     if (network->IsConnectedState()) {
 829       return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_NETWORK_CONNECTED,
 830                                         base::UTF8ToUTF16(network->name()));
 831     }
 832     if (network->IsConnectingState()) {
 833       return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_NETWORK_CONNECTING,
 834                                         base::UTF8ToUTF16(network->name()));
 835     }
 836     if (activation_state == shill::kActivationStateActivating) {
 837       return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_NETWORK_ACTIVATING,
 838                                         base::UTF8ToUTF16(network->name()));
 839     }
 840   }
 841
 842   // Otherwise just show the network name or 'Ethernet'.
 843   if (network->Matches(NetworkTypePattern::Ethernet())) {
 844     return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ETHERNET);
 845   } else {
 846     return base::UTF8ToUTF16(network->name());
 847   }
 848 }
 849
 850 int GetCellularUninitializedMsg() {
 851   static base::Time s_uninitialized_state_time;
 852   static int s_uninitialized_msg(0);
 853
 854   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 855   if (handler->GetTechnologyState(NetworkTypePattern::Mobile())
 856       == NetworkStateHandler::TECHNOLOGY_UNINITIALIZED) {
 857     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR;
 858     s_uninitialized_state_time = base::Time::Now();
 859     return s_uninitialized_msg;
 860   } else if (handler->GetScanningByType(NetworkTypePattern::Mobile())) {
 861     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_CELLULAR_SCANNING;
 862     s_uninitialized_state_time = base::Time::Now();
 863     return s_uninitialized_msg;
 864   }
 865   // There can be a delay between leaving the Initializing state and when
 866   // a Cellular device shows up, so keep showing the initializing
 867   // animation for a bit to avoid flashing the disconnect icon.
 868   const int kInitializingDelaySeconds = 1;
 869   base::TimeDelta dtime = base::Time::Now() - s_uninitialized_state_time;
 870   if (dtime.InSeconds() < kInitializingDelaySeconds)
 871     return s_uninitialized_msg;
 872   return 0;
 873 }
 874
 875 void GetDefaultNetworkImageAndLabel(IconType icon_type,
 876                                     gfx::ImageSkia* image,
 877                                     base::string16* label,
 878                                     bool* animating) {
 879   NetworkStateHandler* state_handler =
 880       NetworkHandler::Get()->network_state_handler();
 881   NetworkConnectionHandler* connect_handler =
 882       NetworkHandler::Get()->network_connection_handler();
 883   const NetworkState* connected_network =
 884       state_handler->ConnectedNetworkByType(NetworkTypePattern::NonVirtual());
 885   const NetworkState* connecting_network =
 886       state_handler->ConnectingNetworkByType(NetworkTypePattern::Wireless());
 887   if (!connecting_network && icon_type == ICON_TYPE_TRAY) {
 888     connecting_network =
 889         state_handler->ConnectingNetworkByType(NetworkTypePattern::VPN());
 890   }
 891
 892   const NetworkState* network;
 893   // If we are connecting to a network, and there is either no connected
 894   // network, or the connection was user requested, use the connecting
 895   // network.
 896   if (connecting_network &&
 897       (!connected_network ||
 898        connect_handler->HasConnectingNetwork(connecting_network->path()))) {
 899     network = connecting_network;
 900   } else {
 901     network = connected_network;
 902   }
 903
 904   // Don't show ethernet in the tray
 905   if (icon_type == ICON_TYPE_TRAY && network &&
 906       network->Matches(NetworkTypePattern::Ethernet())) {
 907     *image = gfx::ImageSkia();
 908     *animating = false;
 909     return;
 910   }
 911
 912   if (!network) {
 913     // If no connecting network, check if we are activating a network.
 914     const NetworkState* mobile_network =
 915         state_handler->FirstNetworkByType(NetworkTypePattern::Mobile());
 916     if (mobile_network && (mobile_network->activation_state() ==
 917                            shill::kActivationStateActivating)) {
 918       network = mobile_network;
 919     }
 920   }
 921   if (!network) {
 922     // If no connecting network, check for cellular initializing.
 923     int uninitialized_msg = GetCellularUninitializedMsg();
 924     if (uninitialized_msg != 0) {
 925       *image = GetImageForConnectingNetwork(icon_type, shill::kTypeCellular);
 926       if (label)
 927         *label = l10n_util::GetStringUTF16(uninitialized_msg);
 928       *animating = true;
 929     } else {
 930       // Otherwise show the disconnected wifi icon.
 931       *image = GetImageForDisconnectedNetwork(icon_type, shill::kTypeWifi);
 932       if (label) {
 933         *label = l10n_util::GetStringUTF16(
 934             IDS_ASH_STATUS_TRAY_NETWORK_NOT_CONNECTED);
 935       }
 936       *animating = false;
 937     }
 938     return;
 939   }
 940   *animating = network->IsConnectingState();
 941   // Get icon and label for connected or connecting network.
 942   *image = GetImageForNetwork(network, icon_type);
 943   if (label)
 944     *label = GetLabelForNetwork(network, icon_type);
 945 }
 946
 947 void PurgeNetworkIconCache() {
 948   NetworkStateHandler::NetworkStateList networks;
 949   NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkList(
 950       &networks);
 951   std::set<std::string> network_paths;
 952   for (NetworkStateHandler::NetworkStateList::iterator iter = networks.begin();
 953        iter != networks.end(); ++iter) {
 954     network_paths.insert((*iter)->path());
 955   }
 956   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
 957   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
 958   PurgeIconMap(ICON_TYPE_LIST, network_paths);
 959 }
 960
 961 }  // namespace network_icon
 962 }  // namespace ui