[cros] Make disconnected icons used by network drop-down and network button consistent.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 2011 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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
@@ skipping 87 matching lines @@
  public:
   explicit NetworkStateInformer(WebUI* web_ui);
   virtual ~NetworkStateInformer();
 
   // Adds observer's callback to be called when network state has been changed.
   void AddObserver(const std::string& callback);
 
   // Removes observer's callback.
   void RemoveObserver(const std::string& callback);
 
-  // Sends current network state, network name and reason using the callback.
+  // Sends current network state, network name, reason and last network type
+  // using the callback.
   void SendState(const std::string& callback, const std::string& reason);
 
   // NetworkLibrary::NetworkManagerObserver implementation:
   virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* cros) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
  private:
   enum State {OFFLINE, ONLINE, CAPTIVE_PORTAL};
 
   bool UpdateState(chromeos::NetworkLibrary* cros);
 
   void SendStateToObservers(const std::string& reason);
 
   content::NotificationRegistrar registrar_;
   base::hash_set<std::string> observers_;
   std::string active_network_;
+  ConnectionType last_network_type_;
   std::string network_name_;
   State state_;
   WebUI* web_ui_;
 };
 
 // NetworkStateInformer implementation -----------------------------------------
 
-NetworkStateInformer::NetworkStateInformer(WebUI* web_ui) : web_ui_(web_ui) {
+NetworkStateInformer::NetworkStateInformer(WebUI* web_ui)
+    : last_network_type_(TYPE_WIFI), web_ui_(web_ui) {

[whywhat, 2011/11/29 07:58:06]

Initialize each member on its own line, please.
I'd initialize state_ as well.

[altimofeev, 2011/11/29 17:10:46]

Done.

   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   UpdateState(cros);
   cros->AddNetworkManagerObserver(this);
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_PROXY_CHANGED,
                  content::NotificationService::AllSources());
 }
 
 NetworkStateInformer::~NetworkStateInformer() {
   CrosLibrary::Get()->GetNetworkLibrary()->
       RemoveNetworkManagerObserver(this);
 }
 
 void NetworkStateInformer::AddObserver(const std::string& callback) {
   observers_.insert(callback);
 }
 
 void NetworkStateInformer::RemoveObserver(const std::string& callback) {
   observers_.erase(callback);
 }
 
 void NetworkStateInformer::SendState(const std::string& callback,
                                      const std::string& reason) {
   base::FundamentalValue state_value(state_);
   base::StringValue network_value(network_name_);
   base::StringValue reason_value(reason);
-  web_ui_->CallJavascriptFunction(callback, state_value,
-                                  network_value, reason_value);
+  base::FundamentalValue last_network_value(last_network_type_);
+  web_ui_->CallJavascriptFunction(callback, state_value, network_value,
+                                  reason_value, last_network_value);
 }
 
 void NetworkStateInformer::OnNetworkManagerChanged(NetworkLibrary* cros) {
   if (UpdateState(cros)) {
     SendStateToObservers(kReasonNetworkChanged);
   }
 }
 
 void NetworkStateInformer::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_LOGIN_PROXY_CHANGED);
   SendStateToObservers(kReasonProxyChanged);
 }
 
 bool NetworkStateInformer::UpdateState(NetworkLibrary* cros) {
+  if (cros->active_network())
+    last_network_type_ = cros->active_network()->type();
+
   State new_state;
   std::string new_active_network;
   if (!cros->Connected()) {
     new_state = OFFLINE;
     network_name_.clear();
   } else {
     const Network* active_network = cros->active_network();
     if (active_network) {
       new_active_network = active_network->unique_id();
       network_name_ = active_network->name();
@@ skipping 540 matching lines @@
 
   cookie_remover_ = new BrowsingDataRemover(
       Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context()),
       BrowsingDataRemover::EVERYTHING,
       base::Time());
   cookie_remover_->AddObserver(this);
   cookie_remover_->Remove(BrowsingDataRemover::REMOVE_SITE_DATA);
 }
 
 }  // namespace chromeos