Deprecate kAshDisableNewNetworkStatusArea

ash/system/chromeos/network/tray_network.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/tray_network.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_icon_animation.h"
-#include "ash/system/chromeos/network/network_list_detailed_view.h"
-#include "ash/system/chromeos/network/network_list_detailed_view_base.h"
 #include "ash/system/chromeos/network/network_state_list_detailed_view.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
 #include "ash/system/chromeos/network/network_tray_delegate.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_item_more.h"
 #include "ash/system/tray/tray_item_view.h"
 #include "ash/system/tray/tray_notification_view.h"
@@ skipping 33 matching lines @@
     case NetworkObserver::MESSAGE_DATA_PROMO:
       if (network_type == TrayNetwork::NETWORK_CELLULAR_LTE)
         return IDR_AURA_UBER_TRAY_NOTIFICATION_LTE;
       else
         return IDR_AURA_UBER_TRAY_NOTIFICATION_3G;
   }
   NOTREACHED();
   return 0;
 }
 
-bool UseNewNetworkHandlers() {
-  return !CommandLine::ForCurrentProcess()->HasSwitch(
-      ash::switches::kAshDisableNewNetworkStatusArea) &&
-      NetworkStateHandler::IsInitialized();
-}
-
 }  // namespace
 
 namespace ash {
 namespace internal {
 
 namespace tray {
 
 class NetworkMessages {
  public:
   struct Message {
@@ skipping 28 matching lines @@
  public:
   explicit NetworkTrayView(TrayNetwork* network_tray)
       : TrayItemView(network_tray),
         network_tray_(network_tray) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
 
     image_view_ = new views::ImageView;
     AddChildView(image_view_);
 
-    NetworkIconInfo info;
-    if (UseNewNetworkHandlers()) {
-      UpdateNetworkStateHandlerIcon();
-    } else {
-      Shell::GetInstance()->system_tray_delegate()->
-          GetMostRelevantNetworkIcon(&info, false);
-      UpdateIcon(info.tray_icon_visible, info.image);
-    }
+    UpdateNetworkStateHandlerIcon();
   }
 
   virtual ~NetworkTrayView() {
-    if (UseNewNetworkHandlers())
-      network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
+    network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
   }
 
   virtual const char* GetClassName() const OVERRIDE {
     return "NetworkTrayView";
   }
 
-  void Update(const NetworkIconInfo& info) {
-    if (UseNewNetworkHandlers())
-      return;
-    UpdateIcon(info.tray_icon_visible, info.image);
-    UpdateConnectionStatus(info.name, info.connected);
-  }
-
   void UpdateNetworkStateHandlerIcon() {
-    DCHECK(UseNewNetworkHandlers());
     NetworkStateHandler* handler = NetworkStateHandler::Get();
     gfx::ImageSkia image;
     base::string16 name;
     bool animating = false;
     network_tray_->GetNetworkStateHandlerImageAndLabel(
         network_icon::ICON_TYPE_TRAY, &image, &name, &animating);
     bool show_in_tray = !image.isNull();
     UpdateIcon(show_in_tray, image);
     if (animating)
       network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
     else
       network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
     // Update accessibility.
     const NetworkState* connected_network = handler->ConnectedNetworkByType(
         NetworkStateHandler::kMatchTypeNonVirtual);
     if (connected_network)
       UpdateConnectionStatus(UTF8ToUTF16(connected_network->name()), true);
     else
       UpdateConnectionStatus(base::string16(), false);
   }
 
   // views::View override.
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE {
     state->name = connection_status_string_;
     state->role = ui::AccessibilityTypes::ROLE_PUSHBUTTON;
   }
 
   // network_icon::AnimationObserver
   virtual void NetworkIconChanged() OVERRIDE {
-    if (UseNewNetworkHandlers())
-      UpdateNetworkStateHandlerIcon();
+    UpdateNetworkStateHandlerIcon();
   }
 
  private:
   // Updates connection status and notifies accessibility event when necessary.
   void UpdateConnectionStatus(const base::string16& network_name,
                               bool connected) {
     base::string16 new_connection_status_string;
     if (connected) {
       new_connection_status_string = l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_NETWORK_CONNECTED, network_name);
@@ skipping 21 matching lines @@
 class NetworkDefaultView : public TrayItemMore,
                            public network_icon::AnimationObserver {
  public:
   NetworkDefaultView(TrayNetwork* network_tray, bool show_more)
       : TrayItemMore(network_tray, show_more),
         network_tray_(network_tray) {
     Update();
   }
 
   virtual ~NetworkDefaultView() {
-    if (UseNewNetworkHandlers())
-      network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
+    network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
   }
 
   void Update() {
-    if (UseNewNetworkHandlers()) {
-      gfx::ImageSkia image;
-      base::string16 label;
-      bool animating = false;
-      network_tray_->GetNetworkStateHandlerImageAndLabel(
-          network_icon::ICON_TYPE_DEFAULT_VIEW, &image, &label, &animating);
-      if (animating)
-        network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
-      else
-        network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
-      SetImage(&image);
-      SetLabel(label);
-      SetAccessibleName(label);
-    } else {
-      NetworkIconInfo info;
-      Shell::GetInstance()->system_tray_delegate()->
-          GetMostRelevantNetworkIcon(&info, true);
-      SetImage(&info.image);
-      SetLabel(info.description);
-      SetAccessibleName(info.description);
-    }
+    gfx::ImageSkia image;
+    base::string16 label;
+    bool animating = false;
+    network_tray_->GetNetworkStateHandlerImageAndLabel(
+        network_icon::ICON_TYPE_DEFAULT_VIEW, &image, &label, &animating);
+    if (animating)
+      network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
+    else
+      network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
+    SetImage(&image);
+    SetLabel(label);
+    SetAccessibleName(label);
   }
 
   // network_icon::AnimationObserver
   virtual void NetworkIconChanged() OVERRIDE {
     Update();
   }
 
  private:
   TrayNetwork* network_tray_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkDefaultView);
 };
 
 class NetworkWifiDetailedView : public NetworkDetailedView {
  public:
-  NetworkWifiDetailedView(SystemTrayItem* owner, bool wifi_enabled)
+  explicit NetworkWifiDetailedView(SystemTrayItem* owner)
       : NetworkDetailedView(owner) {
     SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal,
                                           kTrayPopupPaddingHorizontal,
                                           10,
                                           kTrayPopupPaddingBetweenItems));
-    ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
-    views::ImageView* image = new views::ImageView;
-    const int image_id = wifi_enabled ?
-        IDR_AURA_UBER_TRAY_WIFI_ENABLED : IDR_AURA_UBER_TRAY_WIFI_DISABLED;
-    image->SetImage(bundle.GetImageNamed(image_id).ToImageSkia());
-    AddChildView(image);
+    image_view_ = new views::ImageView;
+    AddChildView(image_view_);
 
-    const int string_id = wifi_enabled ?
-        IDS_ASH_STATUS_TRAY_NETWORK_WIFI_ENABLED:
-        IDS_ASH_STATUS_TRAY_NETWORK_WIFI_DISABLED;
-    views::Label* label =
-        new views::Label(bundle.GetLocalizedString(string_id));
-    label->SetMultiLine(true);
-    label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-    AddChildView(label);
+    label_view_ = new views::Label();
+    label_view_->SetMultiLine(true);
+    label_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    AddChildView(label_view_);
+
+    Update();
   }
 
-  virtual ~NetworkWifiDetailedView() {}
+  virtual ~NetworkWifiDetailedView() {
+  }
 
   // Overridden from NetworkDetailedView:
 
   virtual void Init() OVERRIDE {
   }
 
   virtual NetworkDetailedView::DetailedViewType GetViewType() const OVERRIDE {
     return NetworkDetailedView::WIFI_VIEW;
   }
 
   virtual void ManagerChanged() OVERRIDE {
+    Update();
   }
 
   virtual void NetworkListChanged() OVERRIDE {
   }
 
   virtual void NetworkServiceChanged(
       const chromeos::NetworkState* network) OVERRIDE {
   }
 
  private:
+  void Update() {
+    bool wifi_enabled =
+        NetworkStateHandler::Get()->IsTechnologyEnabled(flimflam::kTypeWifi);
+    const int image_id = wifi_enabled ?
+        IDR_AURA_UBER_TRAY_WIFI_ENABLED : IDR_AURA_UBER_TRAY_WIFI_DISABLED;
+    ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
+    image_view_->SetImage(bundle.GetImageNamed(image_id).ToImageSkia());
+
+    const int string_id = wifi_enabled ?
+        IDS_ASH_STATUS_TRAY_NETWORK_WIFI_ENABLED :
+        IDS_ASH_STATUS_TRAY_NETWORK_WIFI_DISABLED;
+    label_view_->SetText(bundle.GetLocalizedString(string_id));
+  }
+
+  views::ImageView* image_view_;
+  views::Label* label_view_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkWifiDetailedView);
 };
 
 class NetworkMessageView : public views::View,
                            public views::LinkListener {
  public:
   NetworkMessageView(TrayNetwork* tray_network,
                      NetworkObserver::MessageType message_type,
                      const NetworkMessages::Message& network_msg)
       : tray_network_(tray_network),
@@ skipping 99 matching lines @@
 }  // namespace tray
 
 TrayNetwork::TrayNetwork(SystemTray* system_tray)
     : SystemTrayItem(system_tray),
       tray_(NULL),
       default_(NULL),
       detailed_(NULL),
       notification_(NULL),
       messages_(new tray::NetworkMessages()),
       request_wifi_view_(false) {
-  if (UseNewNetworkHandlers())
-    network_state_observer_.reset(new TrayNetworkStateObserver(this));
+  network_state_observer_.reset(new TrayNetworkStateObserver(this));
   if (NetworkStateHandler::IsInitialized())
     network_state_notifier_.reset(new NetworkStateNotifier());
   Shell::GetInstance()->system_tray_notifier()->AddNetworkObserver(this);
 }
 
 TrayNetwork::~TrayNetwork() {
   network_state_notifier_.reset();
   Shell::GetInstance()->system_tray_notifier()->RemoveNetworkObserver(this);
 }
 
@@ skipping 10 matching lines @@
       this, status != user::LOGGED_IN_LOCKED);
   return default_;
 }
 
 views::View* TrayNetwork::CreateDetailedView(user::LoginStatus status) {
   CHECK(detailed_ == NULL);
   // Clear any notifications when showing the detailed view.
   messages_->messages().clear();
   HideNotificationView();
   if (request_wifi_view_) {
-    SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
-    // The Wi-Fi state is not toggled yet at this point.
-    detailed_ = new tray::NetworkWifiDetailedView(this,
-                                                  !delegate->GetWifiEnabled());
+    detailed_ = new tray::NetworkWifiDetailedView(this);
     request_wifi_view_ = false;
   } else {
-    if (UseNewNetworkHandlers()) {
-      detailed_ = new tray::NetworkStateListDetailedView(
-          this, tray::NetworkStateListDetailedView::LIST_TYPE_NETWORK, status);
-    } else {
-      detailed_ = new tray::NetworkListDetailedView(
-          this, status, IDS_ASH_STATUS_TRAY_NETWORK);
-    }
+    detailed_ = new tray::NetworkStateListDetailedView(
+        this, tray::NetworkStateListDetailedView::LIST_TYPE_NETWORK, status);
     detailed_->Init();
   }
   return detailed_;
 }
 
 views::View* TrayNetwork::CreateNotificationView(user::LoginStatus status) {
   CHECK(notification_ == NULL);
   if (messages_->messages().empty())
     return NULL;  // Message has already been cleared.
   notification_ = new tray::NetworkNotificationView(this);
@@ skipping 16 matching lines @@
   notification_ = NULL;
 }
 
 void TrayNetwork::UpdateAfterLoginStatusChange(user::LoginStatus status) {
 }
 
 void TrayNetwork::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   SetTrayImageItemBorder(tray_, alignment);
 }
 
-void TrayNetwork::OnNetworkRefresh(const NetworkIconInfo& info) {
-  if (tray_)
-    tray_->Update(info);
-  if (default_)
-    default_->Update();
-  if (detailed_)
-    detailed_->ManagerChanged();
-}
-
 void TrayNetwork::SetNetworkMessage(NetworkTrayDelegate* delegate,
                                     MessageType message_type,
                                     NetworkType network_type,
                                     const base::string16& title,
                                     const base::string16& message,
                                     const std::vector<base::string16>& links) {
   messages_->messages()[message_type] = tray::NetworkMessages::Message(
       delegate, network_type, title, message, links);
   if (!Shell::GetInstance()->system_tray_delegate()->IsOobeCompleted())
     return;
   if (notification_)
     notification_->Update();
   else
     ShowNotificationView();
 }
 
 void TrayNetwork::ClearNetworkMessage(MessageType message_type) {
   messages_->messages().erase(message_type);
   if (messages_->messages().empty()) {
     HideNotificationView();
     return;
   }
   if (notification_)
     notification_->Update();
   else
     ShowNotificationView();
 }
 
-void TrayNetwork::OnWillToggleWifi() {
-  // Triggered by a user action (e.g. keyboard shortcut)
+void TrayNetwork::RequestToggleWifi() {
+  // This will always be triggered by a user action (e.g. keyboard shortcut)
   if (!detailed_ ||
       detailed_->GetViewType() == tray::NetworkDetailedView::WIFI_VIEW) {
     request_wifi_view_ = true;
     PopupDetailedView(kTrayPopupAutoCloseDelayForTextInSeconds, false);
   }
+  NetworkStateHandler* handler = NetworkStateHandler::Get();
+  bool enabled = handler->IsTechnologyEnabled(flimflam::kTypeWifi);
+  handler->SetTechnologyEnabled(
+      flimflam::kTypeWifi, !enabled,
+      chromeos::network_handler::ErrorCallback());
+}
+
+void TrayNetwork::NetworkManagerChanged() {
+  if (detailed_)
+    detailed_->ManagerChanged();
 }
 
 void TrayNetwork::NetworkStateChanged(bool list_changed) {
-  if (tray_  && UseNewNetworkHandlers())
+  if (tray_)
     tray_->UpdateNetworkStateHandlerIcon();
   if (default_)
     default_->Update();
   if (detailed_) {
     if (list_changed)
       detailed_->NetworkListChanged();
     else
       detailed_->ManagerChanged();
   }
 }
@@ skipping 75 matching lines @@
 
 void TrayNetwork::LinkClicked(MessageType message_type, int link_id) {
   tray::NetworkMessages::MessageMap::const_iterator iter =
       messages()->messages().find(message_type);
   if (iter != messages()->messages().end() && iter->second.delegate)
     iter->second.delegate->NotificationLinkClicked(message_type, link_id);
 }
 
 }  // namespace internal
 }  // namespace ash