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

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/command_line.h"
+#include "base/hash_tables.h"
 #include "base/stringprintf.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #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"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
@@ skipping 34 matching lines @@
   if (sanitized.find('@') == std::string::npos)
     sanitized += kDefaultDomain;
 
   return sanitized;
 }
 
 }  // namespace
 
 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:
   ClearDnsCacheTaskOnIOThread(Task* callback, IOThread* io_thread)
       : callback_(callback), io_thread_(io_thread) {
   }
   virtual ~ClearDnsCacheTaskOnIOThread() {}
 
   // Task overrides.
   virtual void Run() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     if (browser_shutdown::IsTryingToQuit())
      return;
 
     io_thread_->globals()->dnsrr_resolver.get()->OnIPAddressChanged();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback_);
   }
 
  private:
   Task* callback_;
   IOThread* io_thread_;
   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()),
       show_on_init_(false),
       oobe_ui_(false),
       dns_cleared_(false),
       dns_clear_task_running_(false),
       cookies_cleared_(false),
       extension_driven_(
           CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 63 matching lines @@
     // figure out how to make it fast enough.
     SendUserList(false);
 
     ShowScreen(kAccountPickerScreen, NULL);
   }
 }
 
 // SigninScreenHandler, private: -----------------------------------------------
 
 void SigninScreenHandler::Initialize() {
+  network_state_informer_.reset(new NetworkStateInformer(web_ui_));
   if (show_on_init_) {
     show_on_init_ = false;
     Show(oobe_ui_);
   }
 }
 
 void SigninScreenHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("authenticateUser",
       NewCallback(this, &SigninScreenHandler::HandleAuthenticateUser));
   web_ui_->RegisterMessageCallback("completeLogin",
       NewCallback(this, &SigninScreenHandler::HandleCompleteLogin));
   web_ui_->RegisterMessageCallback("getUsers",
       NewCallback(this, &SigninScreenHandler::HandleGetUsers));
   web_ui_->RegisterMessageCallback("launchIncognito",
       NewCallback(this, &SigninScreenHandler::HandleLaunchIncognito));
   web_ui_->RegisterMessageCallback("showAddUser",
       NewCallback(this, &SigninScreenHandler::HandleShowAddUser));
   web_ui_->RegisterMessageCallback("shutdownSystem",
       NewCallback(this, &SigninScreenHandler::HandleShutdownSystem));
   web_ui_->RegisterMessageCallback("removeUser",
       NewCallback(this, &SigninScreenHandler::HandleRemoveUser));
   web_ui_->RegisterMessageCallback("toggleEnrollmentScreen",
       NewCallback(this, &SigninScreenHandler::HandleToggleEnrollmentScreen));
   web_ui_->RegisterMessageCallback("launchHelpApp",
       NewCallback(this, &SigninScreenHandler::HandleLaunchHelpApp));
   web_ui_->RegisterMessageCallback("createAccount",
       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) {
   SendUserList(false);
 }
 
 void SigninScreenHandler::ClearAndEnablePassword() {
   web_ui_->CallJavascriptFunction("cr.ui.Oobe.resetSigninUI");
 }
 
@@ skipping 227 matching lines @@
                                   users_list, animated_value);
 }
 
 void SigninScreenHandler::HandleLoginWebuiReady(const base::ListValue* args) {
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_WEBUI_READY,
       NotificationService::AllSources(),
       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();
 }
 
 void SigninScreenHandler::StartClearingDnsCache() {
   if (dns_clear_task_running_ || !g_browser_process->io_thread())
     return;
 
   dns_cleared_ = false;
   ClearDnsCacheTaskOnIOThread* clear_dns_task = new ClearDnsCacheTaskOnIOThread(
@@ skipping 10 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