[cros,webui] Captive portal on login screen proper handling.

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

Index: chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc
diff --git a/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc b/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc
index ae096085974154ff3bfbe10f794c174cf1366481..b655d2c7124f77894817e8c7b3e5f449ded678f5 100644
--- a/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc
+++ b/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/command_line.h"
+#include "base/hash_tables.h"
 #include "base/stringprintf.h"
 #include "base/task.h"
 #include "base/values.h"
@@ -12,6 +13,7 @@
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/power_library.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
@@ -66,6 +68,38 @@ std::string SanitizeEmail(const std::string& email) {
 
 namespace chromeos {
 
+// Class which observes network state changes and calls registerd callbacks.
+// State is considered changed if connection or the active network has been
+// changed. Also, it answers to the requests about current network state.
+class NetworkStateInformer
+    : public chromeos::NetworkLibrary::NetworkManagerObserver {
+ 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 using the callback.
+  void SendState(const std::string& callback);
+
+  // NetworkLibrary::NetworkManagerObserver implementation:
+  virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* cros) OVERRIDE;
+
+ private:
+  enum State {OFFLINE, ONLINE, CAPTIVE_PORTAL};
+
+  bool UpdateState(chromeos::NetworkLibrary* cros);
+
+  base::hash_set<std::string> observers_;
+  std::string active_network_;
+  State state_;
+  WebUI* web_ui_;
+};
+
 // Clears DNS cache on IO thread.
 class ClearDnsCacheTaskOnIOThread : public Task {
  public:
@@ -90,6 +124,63 @@ class ClearDnsCacheTaskOnIOThread : public Task {
   DISALLOW_COPY_AND_ASSIGN(ClearDnsCacheTaskOnIOThread);
 };
 
+// NetworkStateInformer implementation -----------------------------------------
+
+NetworkStateInformer::NetworkStateInformer(WebUI* web_ui) : web_ui_(web_ui) {
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
+  UpdateState(cros);
+  cros->AddNetworkManagerObserver(this);
+}
+
+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) {
+  base::FundamentalValue state_value(state_);
+  web_ui_->CallJavascriptFunction(callback, state_value);
+}
+
+void NetworkStateInformer::OnNetworkManagerChanged(NetworkLibrary* cros) {
+  if (UpdateState(cros)) {
+    for (base::hash_set<std::string>::iterator it = observers_.begin();
+         it != observers_.end(); ++it) {
+      SendState(*it);
+    }
+  }
+}
+
+bool NetworkStateInformer::UpdateState(NetworkLibrary* cros) {
+  State new_state;
+  std::string new_active_network;
+  if (!cros->Connected()) {
+    new_state = OFFLINE;
+  } else {
+    const Network* active_network = cros->active_network();
+    new_active_network = active_network->unique_id();
+    if (active_network && active_network->restricted_pool()) {
+      new_state = CAPTIVE_PORTAL;
+    } else {
+      new_state = ONLINE;
+    }
+  }
+  bool updated = (new_state != state_) ||
+      (active_network_ != new_active_network);
+  state_ = new_state;
+  active_network_ = new_active_network;
+  return updated;
+}
+
+// SigninScreenHandler implementation ------------------------------------------
 
 SigninScreenHandler::SigninScreenHandler()
     : delegate_(WebUILoginDisplay::GetInstance()),
@@ -173,6 +264,7 @@ void SigninScreenHandler::Show(bool oobe_ui) {
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::Initialize() {
+  network_state_informer_.reset(new NetworkStateInformer(web_ui_));
   if (show_on_init_) {
     show_on_init_ = false;
     Show(oobe_ui_);
@@ -202,6 +294,14 @@ void SigninScreenHandler::RegisterMessages() {
       NewCallback(this, &SigninScreenHandler::HandleCreateAccount));
   web_ui_->RegisterMessageCallback("loginWebuiReady",
       NewCallback(this, &SigninScreenHandler::HandleLoginWebuiReady));
+  web_ui_->RegisterMessageCallback("loginRequestNetworkState",
+      NewCallback(this, &SigninScreenHandler::HandleLoginRequestNetworkState));
+  web_ui_->RegisterMessageCallback("loginAddNetworkStateObserver",
+      NewCallback(this,
+                  &SigninScreenHandler::HandleLoginAddNetworkStateObserver));
+  web_ui_->RegisterMessageCallback("loginRemoveNetworkStateObserver",
+      NewCallback(this,
+                  &SigninScreenHandler::HandleLoginRemoveNetworkStateObserver));
 }
 
 void SigninScreenHandler::HandleGetUsers(const base::ListValue* args) {
@@ -449,6 +549,42 @@ void SigninScreenHandler::HandleLoginWebuiReady(const base::ListValue* args) {
       NotificationService::NoDetails());
 }
 
+void SigninScreenHandler::HandleLoginRequestNetworkState(
+    const base::ListValue* args) {
+  std::string callback;
+  if (!args->GetString(0, &callback)) {
+    NOTREACHED();
+    return;
+  }
+  if (network_state_informer_ == NULL)
+    network_state_informer_.reset(new NetworkStateInformer(web_ui_));

[xiyuan, 2011/09/26 17:06:14]

nit: This should not happen since Initialize should be called before all the
handlers. If we need to do this, could we put it in a EnsureNetworkStateInformer
function?

[altimofeev, 2011/09/26 18:11:41]

Initialize() is called after JS was loaded, but JS uses
'loginAddNetworkObserver' while loading and I don't see any crime in it. So I
have moved initialization of |network_state_informer_| to RegisterMessages(),
since |network_state_informer_| is used by the handlers.

+  network_state_informer_->SendState(callback);
+}
+
+void SigninScreenHandler::HandleLoginAddNetworkStateObserver(
+    const base::ListValue* args) {
+  std::string callback;
+  if (!args->GetString(0, &callback)) {
+    NOTREACHED();
+    return;
+  }
+  if (network_state_informer_ == NULL)
+    network_state_informer_.reset(new NetworkStateInformer(web_ui_));
+  network_state_informer_->AddObserver(callback);
+}
+
+void SigninScreenHandler::HandleLoginRemoveNetworkStateObserver(
+    const base::ListValue* args) {
+  std::string callback;
+  if (!args->GetString(0, &callback)) {
+    NOTREACHED();
+    return;
+  }
+  if (network_state_informer_ == NULL)
+    network_state_informer_.reset(new NetworkStateInformer(web_ui_));
+  network_state_informer_->RemoveObserver(callback);
+}
+
 void SigninScreenHandler::HandleCreateAccount(const base::ListValue* args) {
   delegate_->CreateAccount();
 }