Fix logic for VPN badges and network menu order

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>
@@ skipping 31 matching lines @@
 const int kNumArcsImages = 5;
 gfx::ImageSkia* kArcsImagesAnimatingDark[kNumArcsImages - 1];
 gfx::ImageSkia* kArcsImagesAnimatingLight[kNumArcsImages - 1];
 
 // Badge offsets. The right and bottom offsets are computed based on the size
 // of the network icon and the badge in order to accomodate multiple icon
 // resolutions (ie. standard and high DPI).
 const int kBadgeLeftX = 0;
 const int kBadgeTopY = 0;
 
-// ID for VPN badge.
-const int kVpnBadgeId = IDR_STATUSBAR_VPN_BADGE;
-
 int StrengthIndex(int strength, int count) {
   if (strength == 0) {
     return 0;
   } else {
     // Return an index in the range [1, count].
     const float findex = (static_cast<float>(strength) / 100.0f) *
         nextafter(static_cast<float>(count), 0);
     int index = 1 + static_cast<int>(findex);
     index = max(min(index, count), 1);
     return index;
@@ skipping 107 matching lines @@
   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;
 }
 
 class EmptyImageSource: public gfx::ImageSkiaSource {
  public:
-  EmptyImageSource(const gfx::Size& size)
+  explicit EmptyImageSource(const gfx::Size& size)
       : size_(size) {
   }
 
   virtual gfx::ImageSkiaRep GetImageForScale(
       ui::ScaleFactor scale_factor) OVERRIDE {
     gfx::Size pixel_size = size_.Scale(ui::GetScaleFactorScale(scale_factor));
     SkBitmap empty_bitmap = GetEmptyBitmap(pixel_size);
     return gfx::ImageSkiaRep(empty_bitmap, scale_factor);
   }
  private:
@@ skipping 46 matching lines @@
  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);
 };
 
-gfx::ImageSkia CreateVpnImage() {
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  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);
-}
-
 gfx::ImageSkia GetEmptyImage(const gfx::Size& size) {
   return gfx::ImageSkia(new EmptyImageSource(size), size);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkIcon
 
 // Sets up and generates an ImageSkia for a Network icon.
 class NetworkIcon {
  public:
   // Default constructor is used by the status bar icon (NetworkMenuIcon).
   explicit NetworkIcon(NetworkMenuIcon::ResourceColorTheme color);
 
   // Service path constructor for cached network service icons.
   NetworkIcon(const std::string& service_path,
               NetworkMenuIcon::ResourceColorTheme color);
 
   ~NetworkIcon();
 
   // Resets the icon state.
   void ClearIconAndBadges();
 
   // Resets the saved state to force an update.
   void SetDirty();
 
+  // Updates |vpn_connected_|, returns true if it changed.
+  bool SetOrClearVpnConnected(const Network* network);
+
   // 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();
 
   // Sets up the base icon image.
   void SetIcon(const Network* network);
 
   // Sets up the various badges:
   // top_left: cellular roaming
   // top_right: libcros warning
   // bottom_left: VPN
   // bottom_right: disconnected / secure / technology / warning
   void SetBadges(const Network* network);
 
   // Clears any previous state then sets the base icon and badges.
   void UpdateIcon(const Network* network);
 
   // Generates the image. Call after setting the icon and badges.
   void GenerateImage();
 
   const gfx::ImageSkia GetImage() const { return image_; }
 
+  bool ShouldShowInTray() const;
+
+  void set_type(ConnectionType type) { type_ = type; }
+  void set_state(ConnectionState state) { state_ = state; }
   void set_icon(const gfx::ImageSkia& icon) { icon_ = icon; }
   void set_top_left_badge(const gfx::ImageSkia* badge) {
     top_left_badge_ = badge;
   }
   void set_top_right_badge(const gfx::ImageSkia* badge) {
     top_right_badge_ = badge;
   }
   void set_bottom_left_badge(const gfx::ImageSkia* badge) {
     bottom_left_badge_ = badge;
   }
   void set_bottom_right_badge(const gfx::ImageSkia* badge) {
     bottom_right_badge_ = badge;
   }
 
  private:
   // Updates strength_index_ for wifi or cellular networks.
   // Returns true if |strength_index_| changed.
   bool UpdateWirelessStrengthIndex(const Network* network);
 
   // Updates the local state for cellular networks.
   bool UpdateCellularState(const Network* network);
 
   std::string service_path_;
+  ConnectionType type_;
   ConnectionState state_;
   NetworkMenuIcon::ResourceColorTheme resource_color_theme_;
   int strength_index_;
   gfx::ImageSkia image_;
   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_;
   bool is_status_bar_;
   const Network* connected_network_;  // weak pointer; used for VPN icons.
+  bool vpn_connected_;
   NetworkRoamingState roaming_state_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkIcon);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkIcon
 
 NetworkIcon::NetworkIcon(NetworkMenuIcon::ResourceColorTheme color)
-    : state_(STATE_UNKNOWN),
+    : type_(TYPE_UNKNOWN),
+      state_(STATE_UNKNOWN),
       resource_color_theme_(color),
       strength_index_(-1),
       top_left_badge_(NULL),
       top_right_badge_(NULL),
       bottom_left_badge_(NULL),
       bottom_right_badge_(NULL),
       is_status_bar_(true),
       connected_network_(NULL),
+      vpn_connected_(false),
       roaming_state_(ROAMING_STATE_UNKNOWN) {
 }
 
 NetworkIcon::NetworkIcon(const std::string& service_path,
                          NetworkMenuIcon::ResourceColorTheme color)
     : service_path_(service_path),
+      type_(TYPE_UNKNOWN),
       state_(STATE_UNKNOWN),
       resource_color_theme_(color),
       strength_index_(-1),
       top_left_badge_(NULL),
       top_right_badge_(NULL),
       bottom_left_badge_(NULL),
       bottom_right_badge_(NULL),
       is_status_bar_(false),
       connected_network_(NULL),
+      vpn_connected_(false),
       roaming_state_(ROAMING_STATE_UNKNOWN) {
 }
 
 NetworkIcon::~NetworkIcon() {
 }
 
 void NetworkIcon::ClearIconAndBadges() {
   icon_ = gfx::ImageSkia();
   top_left_badge_ = NULL;
   top_right_badge_ = NULL;
   bottom_left_badge_ = NULL;
   bottom_right_badge_ = NULL;
 }
 
 void NetworkIcon::SetDirty() {
   state_ = STATE_UNKNOWN;
   strength_index_ = -1;
 }
 
+bool NetworkIcon::SetOrClearVpnConnected(const Network* network) {
+  if (network->type() == TYPE_VPN)
+    return false;  // Never show the VPN badge for a VPN network.
+  chromeos::NetworkLibrary* cros =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+  bool vpn_connected = (network->connected() &&
+                        cros->virtual_network() &&
+                        cros->virtual_network()->connected());
+  if (vpn_connected_ != vpn_connected) {
+    vpn_connected_ = vpn_connected;
+    return true;
+  }
+  return false;
+}
+
 void NetworkIcon::Update() {
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   // First look for a visible network.
   const Network* network = cros->FindNetworkByPath(service_path_);
   if (!network) {
     // If not a visible network, check for a remembered network.
     network = cros->FindRememberedNetworkByPath(service_path_);
     if (!network) {
       LOG(WARNING) << "Unable to find network:" << service_path_;
       return;
     }
   }
 
   // Determine whether or not we need to update the icon.
   bool dirty = image_.empty();
 
   // If the network state has changed, the icon needs updating.
   if (state_ != network->state()) {
     state_ = network->state();
     dirty = true;
   }
 
-  ConnectionType type = network->type();
-  if (type == TYPE_WIFI || type == TYPE_WIMAX || type == TYPE_CELLULAR) {
+  type_ = network->type();
+
+  if (type_ == TYPE_WIFI || type_ == TYPE_WIMAX || type_ == TYPE_CELLULAR) {
     if (UpdateWirelessStrengthIndex(network))
       dirty = true;
   }
 
-  if (type == TYPE_CELLULAR) {
+  if (type_ == TYPE_CELLULAR) {
     if (UpdateCellularState(network))
       dirty = true;
   }
 
-  if (type == TYPE_VPN) {
+  if (type_ == TYPE_VPN) {
+    // For VPN, check to see if the connected network has changed.
     if (cros->connected_network() != connected_network_) {
       connected_network_ = cros->connected_network();
       dirty = true;
     }
+  } else {
+    // For non-VPN, check to see if the VPN connection state has changed.
+    if (SetOrClearVpnConnected(network))
+      dirty = true;
   }
 
   if (dirty) {
     // Set the icon and badges based on the network.
     UpdateIcon(network);
     // Generate the image from the icon.
     GenerateImage();
   }
 }
 
 void NetworkIcon::SetIcon(const Network* network) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
-  switch (network->type()) {
+  set_type(network->type());
+  set_state(network->state());
+
+  switch (type_) {
     case TYPE_ETHERNET: {
       icon_ = *rb.GetImageSkiaNamed(IDR_STATUSBAR_WIRED);
       break;
     }
     case TYPE_WIFI: {
       const WifiNetwork* wifi = static_cast<const WifiNetwork*>(network);
       if (strength_index_ == -1)
         strength_index_ = WifiStrengthIndex(wifi);
       icon_ = NetworkMenuIcon::GetImage(
           NetworkMenuIcon::ARCS, strength_index_, resource_color_theme_);
@@ skipping 14 matching lines @@
         strength_index_ = CellularStrengthIndex(cellular);
       icon_ = NetworkMenuIcon::GetImage(
           NetworkMenuIcon::BARS, strength_index_, resource_color_theme_);
       break;
     }
     case TYPE_VPN: {
       icon_ = *rb.GetImageSkiaNamed(IDR_STATUSBAR_VPN);
       break;
     }
     default: {
-      LOG(WARNING) << "Request for icon for unsupported type: "
-                   << network->type();
+      LOG(WARNING) << "Request for icon for unsupported type: " << type_;
       icon_ = *rb.GetImageSkiaNamed(IDR_STATUSBAR_WIRED);
       break;
     }
   }
 }
 
 void NetworkIcon::SetBadges(const Network* network) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
@@ skipping 32 matching lines @@
       }
       if (!cellular->connecting()) {
         top_left_badge_ = BadgeForNetworkTechnology(cellular,
                                                     resource_color_theme_);
       }
       break;
     }
     default:
       break;
   }
-  // Display the VPN badge too.
-  if (resource_color_theme_ == NetworkMenuIcon::COLOR_DARK &&
-      cros->virtual_network() &&
-      (cros->virtual_network()->connected() ||
-       cros->virtual_network()->connecting())) {
-    bottom_left_badge_ = rb.GetImageSkiaNamed(kVpnBadgeId);
-  }
+  if (vpn_connected_)
+    bottom_left_badge_ = rb.GetImageSkiaNamed(IDR_STATUSBAR_VPN_BADGE);
 }
 
 void NetworkIcon::UpdateIcon(const Network* network) {
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  chromeos::NetworkLibrary* cros =
-      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-
   ClearIconAndBadges();
-
-  if (network->type() != TYPE_VPN) {
-    SetIcon(network);
-    SetBadges(network);
-    return;
-  }
-
-  // VPN should never be the primiary active network. This is used for
-  // the icon next to a connected or disconnected VPN.
-  const Network* connected_network = cros->connected_network();
-  if (connected_network && connected_network->type() != TYPE_VPN) {
-    // Set the icon and badges for the connected network.
-    SetIcon(connected_network);
-    SetBadges(connected_network);
-  } else {
-    // Use the ethernet icon for VPN when not connected.
-    icon_ = *rb.GetImageSkiaNamed(IDR_STATUSBAR_WIRED);
-    // We can be connected to a VPN, even when there is no connected
-    // underlying network. In that case, for the status bar, show the
-    // disconnected badge.
-    if (is_status_bar_) {
-      bottom_right_badge_ =
-        rb.GetImageSkiaNamed(IDR_STATUSBAR_NETWORK_DISCONNECTED);
-    }
-  }
-  // Overlay the VPN badge.
-  bottom_left_badge_ = rb.GetImageSkiaNamed(kVpnBadgeId);
+  SetIcon(network);
+  SetBadges(network);
 }
 
 void NetworkIcon::GenerateImage() {
   if (icon_.empty())
     return;
 
   image_ = NetworkMenuIcon::GenerateImageFromComponents(icon_, top_left_badge_,
       top_right_badge_, bottom_left_badge_, bottom_right_badge_);
 }
 
+bool NetworkIcon::ShouldShowInTray() const {
+  if (type_ == TYPE_UNKNOWN || type_ == TYPE_VPN)
+    return false;
+  if (type_ != TYPE_ETHERNET)
+    return true;
+  if (!Network::IsConnectedState(state_))
+    return true;
+  NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
+  if (crosnet->virtual_network() && crosnet->virtual_network()->connecting())
+    return true;
+  return false;
+}
+
 bool NetworkIcon::UpdateWirelessStrengthIndex(const Network* network) {
   bool dirty = false;
   ConnectionType type = network->type();
   int index = 0;
   if (type == TYPE_WIFI) {
     index = WifiStrengthIndex(static_cast<const WifiNetwork*>(network));
   } else if (type == TYPE_WIMAX) {
     index = WimaxStrengthIndex(static_cast<const WimaxNetwork*>(network));
   } else if (type == TYPE_CELLULAR) {
     index = CellularStrengthIndex(static_cast<const CellularNetwork*>(network));
@@ skipping 47 matching lines @@
 // Public methods:
 
 void NetworkMenuIcon::SetResourceColorTheme(ResourceColorTheme color) {
   if (color == resource_color_theme_)
     return;
 
   resource_color_theme_ = color;
   icon_.reset(new NetworkIcon(resource_color_theme_));
 }
 
+bool NetworkMenuIcon::ShouldShowIconInTray() {
+  if (!icon_.get())
+    return false;
+  return icon_->ShouldShowInTray();
+}
+
 const gfx::ImageSkia NetworkMenuIcon::GetIconAndText(string16* text) {
   SetIconAndText();
   if (text)
     *text = text_;
   icon_->GenerateImage();
   return icon_->GetImage();
 }
 
 void NetworkMenuIcon::AnimationProgressed(const ui::Animation* animation) {
   if (animation == &animation_connecting_ && delegate_) {
@@ skipping 28 matching lines @@
   }
   return animation_connecting_.GetCurrentValue();
 }
 
 // TODO(stevenjb): move below SetIconAndText.
 void NetworkMenuIcon::SetConnectingIconAndText() {
   int image_count;
   ImageType image_type;
   gfx::ImageSkia** images;
 
+  icon_->set_type(connecting_network_->type());
+  icon_->set_state(connecting_network_->state());
+
   if (connecting_network_->type() == TYPE_WIFI) {
     image_count = kNumArcsImages - 1;
     image_type = ARCS;
     images = resource_color_theme_ == COLOR_DARK ? kArcsImagesAnimatingDark :
                                                    kArcsImagesAnimatingLight;
   } else {
     image_count = kNumBarsImages - 1;
     image_type = BARS;
     images = resource_color_theme_ == COLOR_DARK ? kBarsImagesAnimatingDark :
                                                    kBarsImagesAnimatingLight;
@@ skipping 55 matching lines @@
 }
 
 void NetworkMenuIcon::SetActiveNetworkIconAndText(const Network* network) {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   bool animating = false;
   last_network_type_ = network->type();
 
   // Set icon and badges. Call SetDirty() since network may have changed.
   icon_->SetDirty();
+  icon_->SetOrClearVpnConnected(network);
   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().
-      vpn_connecting_badge_ = gfx::ImageSkiaOperations::CreateBlendedImage(
-          GetEmptyImage(vpn_badge->size()), *vpn_badge, animation);
-      icon_->set_bottom_left_badge(&vpn_connecting_badge_);
-    }
+  if (network->type() != TYPE_VPN &&
+      cros->virtual_network() && cros->virtual_network()->connecting()) {
+    const gfx::ImageSkia* vpn_badge =
+        rb.GetImageSkiaNamed(IDR_STATUSBAR_VPN_BADGE);
+    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().
+    vpn_connecting_badge_ = gfx::ImageSkiaOperations::CreateBlendedImage(
+        GetEmptyImage(vpn_badge->size()), *vpn_badge, animation);
+    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(
           IDS_STATUSBAR_NETWORK_CONNECTED_TOOLTIP,
           l10n_util::GetStringUTF16(
@@ skipping 89 matching lines @@
     icon = new NetworkIcon(network->service_path(), color);
     icon_map->insert(std::make_pair(network->service_path(), icon));
   } 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 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 = 0;
   gfx::ImageSkia* images = NULL;
   if (type == NetworkMenuIcon::ARCS) {
     if (index >= kNumArcsImages)
       return gfx::ImageSkia();
     images = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         color == NetworkMenuIcon::COLOR_DARK ?
@@ skipping 23 matching lines @@
 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