Deprecate kAshDisableNewNetworkStatusArea

chrome/browser/chromeos/system/ash_system_tray_delegate.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/system/ash_system_tray_delegate.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 48 matching lines @@
 #include "chrome/browser/chromeos/login/login_wizard.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/status/data_promo_notification.h"
 #include "chrome/browser/chromeos/status/network_menu.h"
-#include "chrome/browser/chromeos/status/network_menu_icon.h"
 #include "chrome/browser/chromeos/system/timezone_settings.h"
 #include "chrome/browser/chromeos/system_key_event_listener.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/google_apis/drive_service_interface.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_store.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/ash/volume_controller_chromeos.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 37 matching lines @@
 namespace chromeos {
 
 namespace {
 
 // The minimum session length limit that can be set.
 const int kSessionLengthLimitMinMs = 30 * 1000;  // 30 seconds.
 
 // The maximum session length limit that can be set.
 const int kSessionLengthLimitMaxMs = 24 * 60 * 60 * 1000;  // 24 hours.
 
-ash::NetworkIconInfo CreateNetworkIconInfo(const Network* network) {
-  ash::NetworkIconInfo info;
-  info.name = network->type() == TYPE_ETHERNET ?
-      l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET) :
-      UTF8ToUTF16(network->name());
-  info.image = NetworkMenuIcon::GetImage(network, NetworkMenuIcon::COLOR_DARK);
-  info.service_path = network->service_path();
-  info.connecting = network->connecting();
-  info.connected = network->connected();
-  info.is_cellular = network->type() == TYPE_CELLULAR;
-  return info;
-}
-
 void ExtractIMEInfo(const input_method::InputMethodDescriptor& ime,
                     const input_method::InputMethodUtil& util,
                     ash::IMEInfo* info) {
   info->id = ime.id();
   info->name = util.GetInputMethodLongName(ime);
   info->medium_name = util.GetInputMethodMediumName(ime);
   info->short_name = util.GetInputMethodShortName(ime);
   info->third_party = extension_ime_util::IsExtensionIME(ime.id());
 }
 
@@ skipping 82 matching lines @@
   if (cellular->network_technology() == NETWORK_TECHNOLOGY_LTE ||
       cellular->network_technology() == NETWORK_TECHNOLOGY_LTE_ADVANCED)
     return ash::NetworkObserver::NETWORK_CELLULAR_LTE;
   return ash::NetworkObserver::NETWORK_CELLULAR;
 }
 
 class SystemTrayDelegate : public ash::SystemTrayDelegate,
                            public AudioHandler::VolumeObserver,
                            public PowerManagerClient::Observer,
                            public SessionManagerClient::Observer,
-                           public NetworkMenuIcon::Delegate,
                            public NetworkMenu::Delegate,
                            public NetworkLibrary::NetworkManagerObserver,
-                           public NetworkLibrary::NetworkObserver,
                            public drive::JobListObserver,
                            public content::NotificationObserver,
                            public input_method::InputMethodManager::Observer,
                            public system::TimezoneSettings::Observer,
                            public chromeos::SystemClockClient::Observer,
                            public device::BluetoothAdapter::Observer,
                            public SystemKeyEventListener::CapsLockObserver,
                            public ash::NetworkTrayDelegate,
                            public policy::CloudPolicyStore::Observer {
  public:
   SystemTrayDelegate()
       : ui_weak_ptr_factory_(
             new base::WeakPtrFactory<SystemTrayDelegate>(this)),
-        network_icon_(new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE)),
-        network_icon_dark_(
-            new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE)),
-        network_icon_vpn_(
-            new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE)),
-        network_menu_(new NetworkMenu(this)),
         clock_type_(base::k24HourClock),
         search_key_mapped_to_(input_method::kSearchKey),
         screen_locked_(false),
         have_session_start_time_(false),
         have_session_length_limit_(false),
         data_promo_notification_(new DataPromoNotification()),
         cellular_activating_(false),
         cellular_out_of_credits_(false),
         volume_control_delegate_(new VolumeController()) {
+    if (!CommandLine::ForCurrentProcess()->HasSwitch(
+            chromeos::switches::kUseNewNetworkConfigurationHandlers)) {
+      network_menu_.reset(new NetworkMenu(this));
+    }
+
     // Register notifications on construction so that events such as
     // PROFILE_CREATED do not get missed if they happen before Initialize().
     registrar_.Add(this,
                    chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
                    content::NotificationService::AllSources());
     if (GetUserLoginStatus() == ash::user::LOGGED_IN_NONE) {
       registrar_.Add(this,
@@ skipping 32 matching lines @@
     OnNetworkManagerChanged(crosnet);
 
     input_method::InputMethodManager::Get()->AddObserver(this);
 
     system::TimezoneSettings::GetInstance()->AddObserver(this);
     DBusThreadManager::Get()->GetSystemClockClient()->AddObserver(this);
 
     if (SystemKeyEventListener::GetInstance())
       SystemKeyEventListener::GetInstance()->AddCapsLockObserver(this);
 
-    network_icon_->SetResourceColorTheme(NetworkMenuIcon::COLOR_LIGHT);
-    network_icon_dark_->SetResourceColorTheme(NetworkMenuIcon::COLOR_DARK);
-    network_icon_vpn_->SetResourceColorTheme(NetworkMenuIcon::COLOR_DARK);
-
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&SystemTrayDelegate::InitializeOnAdapterReady,
                    ui_weak_ptr_factory_->GetWeakPtr()));
   }
 
   virtual void Shutdown() OVERRIDE {
     data_promo_notification_.reset();
   }
 
   void InitializeOnAdapterReady(
@@ skipping 100 matching lines @@
       case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED:
         return ash::user::LOGGED_IN_LOCALLY_MANAGED;
       case LoginState::LOGGED_IN_USER_KIOSK_APP:
         return ash::user::LOGGED_IN_KIOSK_APP;
     }
     NOTREACHED();
     return ash::user::LOGGED_IN_NONE;
   }
 
   virtual bool IsOobeCompleted() const OVERRIDE {
+    if (!base::chromeos::IsRunningOnChromeOS() &&
+        LoginState::Get()->GetLoggedInState() == LoginState::LOGGED_IN_ACTIVE)
+      return true;
     return StartupUtils::IsOobeCompleted();
   }
 
   virtual void GetLoggedInUsers(ash::UserEmailList* users) OVERRIDE {
     const UserList& logged_in_users = UserManager::Get()->GetLoggedInUsers();
     for (UserList::const_iterator it = logged_in_users.begin();
          it != logged_in_users.end(); ++it) {
       const User* user = (*it);
       users->push_back(user->email());
     }
@@ skipping 311 matching lines @@
   virtual void GetDriveOperationStatusList(
       ash::DriveOperationStatusList* list) OVERRIDE {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
     *list = ConvertToDriveStatusList(
         system_service->job_list()->GetJobInfoList());
   }
 
-
-  virtual void GetMostRelevantNetworkIcon(ash::NetworkIconInfo* info,
-                                          bool dark) OVERRIDE {
-    NetworkMenuIcon* icon =
-        dark ? network_icon_dark_.get() : network_icon_.get();
-    info->image = icon->GetIconAndText(&info->description);
-    info->tray_icon_visible = icon->ShouldShowIconInTray();
-  }
-
-  virtual void GetVirtualNetworkIcon(ash::NetworkIconInfo* info) OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    if (crosnet->virtual_network_connected()) {
-      NetworkMenuIcon* icon = network_icon_vpn_.get();
-      info->image = icon->GetVpnIconAndText(&info->description);
-      info->tray_icon_visible = false;
-    } else {
-      gfx::ImageSkia* image = NetworkMenuIcon::GetVirtualNetworkImage();
-      info->image = *image;
-      info->description = l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_VPN_DISCONNECTED);
-    }
-  }
-
-  virtual void GetAvailableNetworks(
-      std::vector<ash::NetworkIconInfo>* list) OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-
-    std::set<const Network*> added;
-
-    // Add the active network first.
-    if (crosnet->active_nonvirtual_network())
-      AddNetworkToList(list, &added, crosnet->active_nonvirtual_network());
-
-    if (crosnet->ethernet_network() &&
-        crosnet->ethernet_network()->connecting_or_connected()) {
-      AddNetworkToList(list, &added, crosnet->ethernet_network());
-    }
-    if (crosnet->cellular_network()
-        && crosnet->cellular_network()->connecting_or_connected()) {
-      AddNetworkToList(list, &added, crosnet->cellular_network());
-    }
-    if (crosnet->wimax_network()
-        && crosnet->wimax_network()->connecting_or_connected()) {
-      AddNetworkToList(list, &added, crosnet->wimax_network());
-    }
-    if (crosnet->wifi_network()
-        && crosnet->wifi_network()->connecting_or_connected()) {
-      AddNetworkToList(list, &added, crosnet->wifi_network());
-    }
-
-    // Add remaining networks by type.
-
-    // Ethernet.
-    if (crosnet->ethernet_available() && crosnet->ethernet_enabled()) {
-      const EthernetNetwork* ethernet_network = crosnet->ethernet_network();
-      if (ethernet_network)
-        AddNetworkToList(list, &added, ethernet_network);
-    }
-
-    // Cellular.
-    if (crosnet->cellular_available() && crosnet->cellular_enabled()) {
-      const CellularNetworkVector& cell = crosnet->cellular_networks();
-      for (size_t i = 0; i < cell.size(); ++i)
-        AddNetworkToList(list, &added, cell[i]);
-    }
-
-    // Wimax.
-    if (crosnet->wimax_available() && crosnet->wimax_enabled()) {
-      const WimaxNetworkVector& wimax = crosnet->wimax_networks();
-      for (size_t i = 0; i < wimax.size(); ++i)
-        AddNetworkToList(list, &added, wimax[i]);
-    }
-
-    // Wifi.
-    if (crosnet->wifi_available() && crosnet->wifi_enabled()) {
-      const WifiNetworkVector& wifi = crosnet->wifi_networks();
-      for (size_t i = 0; i < wifi.size(); ++i)
-        AddNetworkToList(list, &added, wifi[i]);
-    }
-  }
-
-  virtual void GetVirtualNetworks(
-      std::vector<ash::NetworkIconInfo>* list) OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    std::set<const Network*> added;
-
-    // Add connected/connecting vpn first.
-    if (crosnet->virtual_network()
-        && crosnet->virtual_network()->connecting_or_connected()) {
-      AddNetworkToList(list, &added, crosnet->virtual_network());
-    }
-
-    // VPN (only if logged in).
-    if (GetUserLoginStatus() != ash::user::LOGGED_IN_NONE &&
-        (crosnet->connected_network() ||
-         crosnet->virtual_network_connected())) {
-      const VirtualNetworkVector& vpns = crosnet->virtual_networks();
-      for (size_t i = 0; i < vpns.size(); ++i)
-        AddNetworkToList(list, &added, vpns[i]);
-    }
-  }
-
-  virtual void GetNetworkAddresses(std::string* ip_address,
-                                   std::string* ethernet_mac_address,
-                                   std::string* wifi_mac_address) OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    if (crosnet->Connected())
-      *ip_address = crosnet->IPAddress();
-    else
-      *ip_address = std::string();
-
-    *ethernet_mac_address = std::string();
-    const NetworkDevice* ether = crosnet->FindEthernetDevice();
-    if (ether)
-      crosnet->GetIPConfigsAndBlock(ether->device_path(), ethernet_mac_address,
-          NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
-
-    *wifi_mac_address = std::string();
-    const NetworkDevice* wifi = crosnet->wifi_enabled() ?
-        crosnet->FindWifiDevice() : NULL;
-    if (wifi)
-      crosnet->GetIPConfigsAndBlock(wifi->device_path(), wifi_mac_address,
-          NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
-  }
-
   virtual void ConfigureNetwork(const std::string& network_id) OVERRIDE {
     const chromeos::NetworkState* network = network_id.empty() ? NULL :
         chromeos::NetworkStateHandler::Get()->GetNetworkState(network_id);
     if (!network) {
       LOG(ERROR) << "ConfigureNetwork: Network not found: " << network_id;
       return;
     }
     if (network->type() == flimflam::kTypeWifi ||
         network->type() == flimflam::kTypeWimax ||
         network->type() == flimflam::kTypeVPN) {
@@ skipping 17 matching lines @@
     DCHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
         chromeos::switches::kUseNewNetworkConfigurationHandlers));
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
     Network* network = crosnet->FindNetworkByPath(network_id);
     if (network)
       network_menu_->ConnectToNetwork(network);  // Shows settings if connected
     else
       ShowNetworkSettings("");
   }
 
-  virtual void RequestNetworkScan() OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    crosnet->RequestNetworkScan();
-  }
-
   virtual void AddBluetoothDevice() OVERRIDE {
     // Open the Bluetooth device dialog, which automatically starts the
     // discovery process.
     content::RecordAction(
         content::UserMetricsAction("OpenAddBluetoothDeviceDialog"));
     chrome::ShowSettingsSubPage(GetAppropriateBrowser(),
                                 chrome::kBluetoothAddDeviceSubPage);
   }
 
-  virtual void ToggleAirplaneMode() OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    crosnet->EnableOfflineMode(!crosnet->offline_mode());
-  }
-
-  virtual void ToggleWifi() OVERRIDE {
-    GetSystemTrayNotifier()->NotifyWillToggleWifi();
-    network_menu_->ToggleWifi();
-  }
-
-  virtual void ToggleMobile() OVERRIDE {
-    network_menu_->ToggleMobile();
-  }
-
   virtual void ToggleBluetooth() OVERRIDE {
     bluetooth_adapter_->SetPowered(!bluetooth_adapter_->IsPowered(),
                                    base::Bind(&base::DoNothing),
                                    base::Bind(&BluetoothPowerFailure));
   }
 
   virtual void ShowMobileSimDialog() OVERRIDE {
     SimDialogDelegate::ShowDialog(GetNativeWindow(),
                                   SimDialogDelegate::SIM_DIALOG_UNLOCK);
   }
 
   virtual void ShowOtherWifi() OVERRIDE {
-    network_menu_->ShowOtherWifi();
+    NetworkConfigView::ShowForType(chromeos::TYPE_WIFI, GetNativeWindow());
   }
 
   virtual void ShowOtherVPN() OVERRIDE {
-    network_menu_->ShowOtherVPN();
+    NetworkConfigView::ShowForType(chromeos::TYPE_VPN, GetNativeWindow());
   }
 
   virtual void ShowOtherCellular() OVERRIDE {
-    network_menu_->ShowOtherCellular();
-  }
-
-  virtual bool IsNetworkConnected() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->Connected();
-  }
-
-  virtual bool GetWifiAvailable() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->wifi_available();
-  }
-
-  virtual bool GetMobileAvailable() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->mobile_available();
+    ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
   }
 
   virtual bool GetBluetoothAvailable() OVERRIDE {
     return bluetooth_adapter_->IsPresent();
   }
 
-  virtual bool GetWifiEnabled() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->wifi_enabled();
-  }
-
-  virtual bool GetMobileEnabled() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->mobile_enabled();
-  }
-
   virtual bool GetBluetoothEnabled() OVERRIDE {
     return bluetooth_adapter_->IsPowered();
   }
 
-  virtual bool GetMobileScanSupported() OVERRIDE {
-    NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
-    const NetworkDevice* mobile = crosnet->FindMobileDevice();
-    return mobile ? mobile->support_network_scan() : false;
-  }
-
   virtual bool GetCellularCarrierInfo(std::string* carrier_id,
                                       std::string* topup_url,
                                       std::string* setup_url) OVERRIDE {
     bool result = false;
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
     const NetworkDevice* cellular = crosnet->FindCellularDevice();
     if (!cellular)
       return false;
 
     MobileConfig* config = MobileConfig::GetInstance();
@@ skipping 10 matching lines @@
         // Only link to setup URL if SIM card is not inserted.
         if (cellular->is_sim_absent()) {
           *setup_url = locale_config->setup_url();
           result = true;
         }
       }
     }
     return result;
   }
 
-  virtual bool GetWifiScanning() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->wifi_scanning();
-  }
-
-  virtual bool GetCellularInitializing() OVERRIDE {
-    return CrosLibrary::Get()->GetNetworkLibrary()->cellular_initializing();
-  }
-
   virtual void ShowCellularURL(const std::string& url) OVERRIDE {
     chrome::ShowSingletonTab(GetAppropriateBrowser(), GURL(url));
   }
 
   virtual void ChangeProxySettings() OVERRIDE {
     CHECK(GetUserLoginStatus() == ash::user::LOGGED_IN_NONE);
     LoginDisplayHostImpl::default_host()->OpenProxySettings();
   }
 
   virtual ash::VolumeControlDelegate*
@@ skipping 117 matching lines @@
           std::min(std::max(local_state->GetInteger(prefs::kSessionLengthLimit),
                             kSessionLengthLimitMinMs),
                    kSessionLengthLimitMaxMs));
     } else {
       have_session_length_limit_ = false;
       session_length_limit_ = base::TimeDelta();
     }
     GetSystemTrayNotifier()->NotifySessionLengthLimitChanged();
   }
 
-  void NotifyRefreshNetwork() {
-    chromeos::NetworkLibrary* crosnet =
-        chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-    const Network* network = crosnet->connected_network();
-    ash::NetworkIconInfo info;
-    if (network)
-      info = CreateNetworkIconInfo(network);
-    info.image = network_icon_->GetIconAndText(&info.description);
-    info.tray_icon_visible = network_icon_->ShouldShowIconInTray();
-    GetSystemTrayNotifier()->NotifyRefreshNetwork(info);
-    GetSystemTrayNotifier()->NotifyVpnRefreshNetwork(info);
-  }
-
-  void RefreshNetworkObserver(NetworkLibrary* crosnet) {
-    const Network* network = crosnet->active_nonvirtual_network();
-    std::string new_path = network ? network->service_path() : std::string();
-    if (active_network_path_ != new_path) {
-      if (!active_network_path_.empty())
-        crosnet->RemoveNetworkObserver(active_network_path_, this);
-      if (!new_path.empty())
-        crosnet->AddNetworkObserver(new_path, this);
-      active_network_path_ = new_path;
-    }
-  }
-
-  void AddNetworkToList(std::vector<ash::NetworkIconInfo>* list,
-                        std::set<const Network*>* added,
-                        const Network* network) {
-    // Only add networks to the list once.
-    if (added->find(network) != added->end())
-      return;
-
-    ash::NetworkIconInfo info = CreateNetworkIconInfo(network);
-    switch (network->type()) {
-      case TYPE_ETHERNET:
-        if (info.name.empty()) {
-          info.name =
-              l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
-        }
-        break;
-      case TYPE_CELLULAR: {
-        const CellularNetwork* cellular =
-            static_cast<const CellularNetwork*>(network);
-        ActivationState state = cellular->activation_state();
-        if (state == ACTIVATION_STATE_NOT_ACTIVATED ||
-            state == ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
-          // If a cellular network needs to be activated,
-          // then do not show it in the lock screen.
-          if (GetUserLoginStatus() == ash::user::LOGGED_IN_LOCKED)
-            return;
-
-          info.description = l10n_util::GetStringFUTF16(
-              IDS_ASH_STATUS_TRAY_NETWORK_LIST_ACTIVATE, info.name);
-        } else if (state == ACTIVATION_STATE_ACTIVATING) {
-          info.description = l10n_util::GetStringFUTF16(
-              IDS_ASH_STATUS_TRAY_NETWORK_LIST_ACTIVATING, info.name);
-        } else if (network->connecting()) {
-          info.description = l10n_util::GetStringFUTF16(
-              IDS_STATUSBAR_NETWORK_DEVICE_STATUS,
-              info.name, l10n_util::GetStringUTF16(
-                  IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
-        }
-        break;
-      }
-      case TYPE_VPN:
-      case TYPE_WIFI:
-      case TYPE_WIMAX:
-      case TYPE_BLUETOOTH:
-      case TYPE_UNKNOWN:
-        break;
-    }
-    if (network->connecting()) {
-      info.description = l10n_util::GetStringFUTF16(
-          IDS_STATUSBAR_NETWORK_DEVICE_STATUS,
-          info.name,
-          l10n_util::GetStringUTF16(
-              IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
-    }
-    added->insert(network);
-    list->push_back(info);
-  }
-
   // Overridden from AudioHandler::VolumeObserver.
   virtual void OnVolumeChanged() OVERRIDE {
     float level = AudioHandler::GetInstance()->GetVolumePercent() / 100.f;
     GetSystemTrayNotifier()->NotifyVolumeChanged(level);
   }
 
   // Overridden from AudioHandler::VolumeObserver.
   virtual void OnMuteToggled() OVERRIDE {
     GetSystemTrayNotifier()->NotifyMuteToggled();
   }
@@ skipping 17 matching lines @@
   }
 
   virtual void UnlockScreen() OVERRIDE {
     screen_locked_ = false;
     ash::Shell::GetInstance()->UpdateAfterLoginStatusChange(
         GetUserLoginStatus());
   }
 
   // TODO(sad): Override more from PowerManagerClient::Observer here.
 
-  // Overridden from NetworkMenuIcon::Delegate.
-  virtual void NetworkMenuIconChanged() OVERRIDE {
-    NotifyRefreshNetwork();
-  }
-
   // Overridden from NetworkMenu::Delegate.
   virtual gfx::NativeWindow GetNativeWindow() const OVERRIDE {
     return GetNativeWindowByStatus(GetUserLoginStatus());
   }
 
   virtual void OpenButtonOptions() OVERRIDE {
   }
 
   virtual bool ShouldOpenButtonOptions() const OVERRIDE {
     return false;
   }
 
   // Overridden from NetworkLibrary::NetworkManagerObserver.
   virtual void OnNetworkManagerChanged(NetworkLibrary* crosnet) OVERRIDE {
-    RefreshNetworkObserver(crosnet);
+    // TODO(stevenjb): Migrate to NetworkStateHandler.
     data_promo_notification_->ShowOptionalMobileDataPromoNotification(
         crosnet, GetPrimarySystemTray(), this);
     UpdateCellular();
-
-    NotifyRefreshNetwork();
-  }
-
-  // Overridden from NetworkLibrary::NetworkObserver.
-  virtual void OnNetworkChanged(NetworkLibrary* crosnet,
-      const Network* network) OVERRIDE {
-    NotifyRefreshNetwork();
   }
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_UPGRADE_RECOMMENDED: {
         UpgradeDetector* detector =
             content::Source<UpgradeDetector>(source).ptr();
@@ skipping 231 matching lines @@
     if (cellular->activation_state() == ACTIVATION_STATE_ACTIVATING) {
       cellular_activating_ = true;
     } else if (cellular->activated() && cellular_activating_) {
       cellular_activating_ = false;
       ash::NetworkObserver::NetworkType type = NetworkTypeForCellular(cellular);
       ash::Shell::GetInstance()->system_tray_notifier()->
           NotifySetNetworkMessage(
               NULL,
               ash::NetworkObserver::MESSAGE_DATA_PROMO,
               type,
-              l10n_util::GetStringUTF16(
-                  IDS_NETWORK_CELLULAR_ACTIVATED_TITLE),
-              l10n_util::GetStringFUTF16(
-                  IDS_NETWORK_CELLULAR_ACTIVATED,
-                  UTF8ToUTF16((cellular->name()))),
-                  std::vector<string16>());
-    }
-    if (!CommandLine::ForCurrentProcess()->HasSwitch(
-            ash::switches::kAshDisableNewNetworkStatusArea)) {
-      return;
-    }
-    // Trigger "Out of credits" notification (for NetworkLibrary impl)
-    if (cellular->out_of_credits() && !cellular_out_of_credits_) {
-      cellular_out_of_credits_ = true;
-      ash::NetworkObserver::NetworkType type = NetworkTypeForCellular(cellular);
-      std::vector<string16> links;
-      links.push_back(
-          l10n_util::GetStringFUTF16(IDS_NETWORK_OUT_OF_CREDITS_LINK,
-                                     UTF8ToUTF16(cellular->name())));
-      ash::Shell::GetInstance()->system_tray_notifier()->
-          NotifySetNetworkMessage(
-              this, ash::NetworkObserver::ERROR_OUT_OF_CREDITS, type,
-              l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_CREDITS_TITLE),
-              l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_CREDITS_BODY),
-              links);
-    } else if (!cellular->out_of_credits() && cellular_out_of_credits_) {
-      cellular_out_of_credits_ = false;
+              l10n_util::GetStringUTF16(IDS_NETWORK_CELLULAR_ACTIVATED_TITLE),
+              l10n_util::GetStringFUTF16(IDS_NETWORK_CELLULAR_ACTIVATED,
+                                         UTF8ToUTF16((cellular->name()))),
+              std::vector<string16>());
     }
   }
 
   scoped_ptr<base::WeakPtrFactory<SystemTrayDelegate> > ui_weak_ptr_factory_;
-  scoped_ptr<NetworkMenuIcon> network_icon_;
-  scoped_ptr<NetworkMenuIcon> network_icon_dark_;
-  scoped_ptr<NetworkMenuIcon> network_icon_vpn_;
   scoped_ptr<NetworkMenu> network_menu_;
   content::NotificationRegistrar registrar_;
   PrefChangeRegistrar local_state_registrar_;
   scoped_ptr<PrefChangeRegistrar> user_pref_registrar_;
   std::string active_network_path_;
   base::HourClockType clock_type_;
   int search_key_mapped_to_;
   bool screen_locked_;
   bool have_session_start_time_;
   base::TimeTicks session_start_time_;
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate() {
   return new chromeos::SystemTrayDelegate();
 }
 
 }  // namespace chromeos