Merge 180012

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 "ash/system/chromeos/network/network_icon_animation.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_util.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "grit/generated_resources.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_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/size_conversions.h"
 
 using std::max;
 using std::min;
 
+using ash::network_icon::NetworkIconAnimation;
+
 namespace chromeos {
 
 namespace {
 
 // Amount to fade icons while connecting.
 const double kConnectingImageAlpha = 0.5;
 
-// Animation cycle length.
-const int kThrobDurationMs = 750;
-
 // Images for strength bars for wired networks.
 const int kNumBarsImages = 5;
 gfx::ImageSkia* kBarsImagesAnimatingDark[kNumBarsImages - 1];
 gfx::ImageSkia* kBarsImagesAnimatingLight[kNumBarsImages - 1];
 
 // Imagaes for strength arcs for wireless networks.
 const int kNumArcsImages = 5;
 gfx::ImageSkia* kArcsImagesAnimatingDark[kNumArcsImages - 1];
 gfx::ImageSkia* kArcsImagesAnimatingLight[kNumArcsImages - 1];
 
@@ skipping 227 matching lines @@
   // 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;
 
+  ConnectionType type() { return type_; }
   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) {
@@ skipping 305 matching lines @@
   return dirty;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuIcon
 
 NetworkMenuIcon::NetworkMenuIcon(Delegate* delegate, Mode mode)
     : mode_(mode),
       delegate_(delegate),
       resource_color_theme_(COLOR_DARK),
-      ALLOW_THIS_IN_INITIALIZER_LIST(animation_connecting_(this)),
-      connecting_network_(NULL) {
-  // Set up the connection animation throbber.
-  animation_connecting_.SetThrobDuration(kThrobDurationMs);
-  animation_connecting_.SetTweenType(ui::Tween::LINEAR);
-
+      connecting_index_(-1) {
   // Initialize the icon.
   icon_.reset(new NetworkIcon(resource_color_theme_));
 }
 
 NetworkMenuIcon::~NetworkMenuIcon() {
 }
 
 // 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 (SetIconAndText())
+    NetworkIconAnimation::GetInstance()->AddObserver(this);
+  else
+    NetworkIconAnimation::GetInstance()->RemoveObserver(this);
   if (text)
     *text = text_;
   icon_->GenerateImage();
   return icon_->GetImage();
 }
 
 const gfx::ImageSkia NetworkMenuIcon::GetVpnIconAndText(string16* text) {
-  SetVpnIconAndText();
+  if (SetVpnIconAndText())
+    NetworkIconAnimation::GetInstance()->AddObserver(this);
+  else
+    NetworkIconAnimation::GetInstance()->RemoveObserver(this);
   if (text)
     *text = text_;
   icon_->GenerateImage();
   return icon_->GetImage();
 }
 
-void NetworkMenuIcon::AnimationProgressed(const ui::Animation* animation) {
-  if (animation == &animation_connecting_ && delegate_) {
-    // Only update the connecting network from here.
-    if (GetConnectingNetwork() == connecting_network_)
-      delegate_->NetworkMenuIconChanged();
+void NetworkMenuIcon::NetworkIconChanged() {
+  if (!delegate_ || !icon_.get())
+    return;
+  // Only send a message when the icon would change.
+  int connecting_index = GetConnectingIndex();
+  if (connecting_index != connecting_index_) {
+    connecting_index_ = connecting_index;
+    delegate_->NetworkMenuIconChanged();
   }
 }
 
 // Private methods:
 
 // If disconnected: returns any connecting non-ethernet network.
 // Otherwise, only return a network if the conenction was user initiated.
 const Network* NetworkMenuIcon::GetConnectingNetwork() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   const Network* connecting_network = cros->connecting_network();
   if (connecting_network &&
       connecting_network->type() != TYPE_ETHERNET &&
       (!cros->connected_network() ||
        connecting_network->connection_started())) {
     return connecting_network;
   }
   return NULL;
 }
 
 double NetworkMenuIcon::GetAnimation() {
-  if (!animation_connecting_.is_animating()) {
-    animation_connecting_.Reset();
-    animation_connecting_.StartThrobbing(-1 /*throb indefinitely*/);
-    return 0;
-  }
-  return animation_connecting_.GetCurrentValue();
+  return NetworkIconAnimation::GetInstance()->GetAnimation();
 }
 
+int NetworkMenuIcon::GetConnectingIndex() {
+  DCHECK(icon_.get());
+  double animation = GetAnimation();
+  int image_count =
+      (icon_->type() == TYPE_WIFI) ? kNumArcsImages - 1 : kNumBarsImages - 1;
+  int index = animation * nextafter(static_cast<float>(image_count), 0);
+  return std::max(std::min(index, image_count - 1), 0);
+}
+
+
 // TODO(stevenjb): move below SetIconAndText.
-void NetworkMenuIcon::SetConnectingIconAndText() {
-  int image_count;
-  ImageType image_type;
-  gfx::ImageSkia** images;
-
+void NetworkMenuIcon::SetConnectingIconAndText(
+    const Network* connecting_network) {
+  connecting_network_ = connecting_network;
   ConnectionType type;
   ConnectionState state;
   if (connecting_network_) {
     type = connecting_network_->type();
     state = connecting_network_->state();
     if (mode_ == MENU_MODE) {
       text_ = l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_CONNECTING_TOOLTIP,
           UTF8ToUTF16(connecting_network_->name()));
     } else {
       text_ = UTF8ToUTF16(connecting_network_->name());
     }
   } else {
     // When called with no connecting network, cellular is initializing.
     type = TYPE_CELLULAR;
     state = STATE_ASSOCIATION;
     text_ = l10n_util::GetStringUTF16(
         IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR);
   }
   icon_->set_type(type);
   icon_->set_state(state);
 
+  ImageType image_type;
+  gfx::ImageSkia** images;
   if (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;
   }
-  int index = GetAnimation() * nextafter(static_cast<float>(image_count), 0);
-  index = std::max(std::min(index, image_count - 1), 0);
+  int index = GetConnectingIndex();
 
   // Lazily cache images.
   if (!images[index]) {
     gfx::ImageSkia source =
         GetImage(image_type, index + 1, resource_color_theme_);
     images[index] =
         new gfx::ImageSkia(NetworkMenuIcon::GenerateConnectingImage(source));
   }
   icon_->set_icon(*images[index]);
   if (connecting_network_)
     icon_->SetBadges(connecting_network_);
 }
 
 // Sets up the icon and badges for GenerateBitmap().
-void NetworkMenuIcon::SetIconAndText() {
+bool NetworkMenuIcon::SetIconAndText() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   DCHECK(cros);
 
   icon_->ClearIconAndBadges();
 
   // If we are connecting to a network and it was user-initiated or we are
   // not connected, display that.
-  connecting_network_ = GetConnectingNetwork();
-  if (connecting_network_) {
-    SetConnectingIconAndText();
-    return;
+  const Network* connecting_network = GetConnectingNetwork();
+  if (connecting_network) {
+    SetConnectingIconAndText(connecting_network);
+    return true;
   }
 
   // If not connecting to a network, show the active or connected network.
   const Network* network;
   if (mode_ == DROPDOWN_MODE && cros->connected_network())
     network = cros->connected_network();
   else
     network = cros->active_nonvirtual_network();
-  if (network) {
-    SetActiveNetworkIconAndText(network);
-    return;
-  }
+  if (network)
+    return SetActiveNetworkIconAndText(network);
 
   // If no connected network, check if we are initializing Cellular.
   if (mode_ != DROPDOWN_MODE && cros->cellular_initializing()) {
     initialize_state_time_ = base::Time::Now();
-    SetConnectingIconAndText();
-    return;
+    SetConnectingIconAndText(NULL);
+    return true;
   }
   // There can be a delay between leaving the Initializing state and when a
   // Cellular device shows up, so keep showing the initializing animation
   // for a few extra seconds to avoid flashing the disconnect icon.
   const int kInitializingDelaySeconds = 1;
   base::TimeDelta dtime = base::Time::Now() - initialize_state_time_;
   if (dtime.InSeconds() < kInitializingDelaySeconds) {
-    SetConnectingIconAndText();
-    return;
+    SetConnectingIconAndText(NULL);
+    return true;
   }
 
-  // Not connecting, so stop animation.
-  animation_connecting_.Stop();
-
   // No connecting, connected, or active network.
   SetDisconnectedIconAndText();
+  return false;
 }
 
-void NetworkMenuIcon::SetVpnIconAndText() {
+bool NetworkMenuIcon::SetVpnIconAndText() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   DCHECK(cros);
 
   icon_->ClearIconAndBadges();
   const VirtualNetwork* vpn = cros->virtual_network();
   if (!vpn) {
-    NOTREACHED();
+    LOG(WARNING) << "SetVpnIconAndText called with no VPN";
     SetDisconnectedIconAndText();
-    return;
+    return false;
   }
   if (vpn->connecting()) {
-    connecting_network_ = vpn;
-    SetConnectingIconAndText();
-    return;
+    SetConnectingIconAndText(vpn);
+    return true;
   }
 
-  // If not connecting to a network, show the active/connected VPN.
-  SetActiveNetworkIconAndText(vpn);
+  // If not connecting to a VPN, show the active/connected VPN.
+  return SetActiveNetworkIconAndText(vpn);
 }
 
-void NetworkMenuIcon::SetActiveNetworkIconAndText(const Network* network) {
+bool NetworkMenuIcon::SetActiveNetworkIconAndText(const Network* network) {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   bool animating = false;
 
   // 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() && cros->virtual_network()->connecting()) {
     const gfx::ImageSkia* vpn_badge =
         rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_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(
               IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET));
     } else {
       text_ = l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
     }
   } else {
     if (mode_ == MENU_MODE) {
       text_ = l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_CONNECTED_TOOLTIP,
           UTF8ToUTF16(network->name()));
     } else {
       text_ = UTF8ToUTF16(network->name());
     }
   }
+  return animating;
 }
 
 void NetworkMenuIcon::SetDisconnectedIconAndText() {
   icon_->set_icon(GetDisconnectedImage(ARCS, resource_color_theme_));
   if (mode_ == MENU_MODE)
     text_ = l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_NO_NETWORK_TOOLTIP);
   else
     text_ = l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_NONE_SELECTED);
 }
 
@@ skipping 101 matching lines @@
 gfx::ImageSkia* NetworkMenuIcon::GetVirtualNetworkImage() {
   return ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
       IDR_AURA_UBER_TRAY_NETWORK_VPN);
 }
 
 int NetworkMenuIcon::NumImages(ImageType type) {
   return (type == ARCS) ? kNumArcsImages : kNumBarsImages;
 }
 
 }  // chromeos