kiosk: Network connectivity test during launch.

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

 // Copyright 2013 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/app_launch_splash_screen_handler.h"
 
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/chromeos/login/screens/error_screen_actor.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #include "grit/browser_resources.h"
 #include "grit/chrome_unscaled_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 
 namespace {
 
 const char kJsScreenPath[] = "login.AppLaunchSplashScreen";
 
+// Returns network name by service path.
+std::string GetNetworkName(const std::string& service_path) {
+  const chromeos::NetworkState* network =
+      chromeos::NetworkHandler::Get()->network_state_handler()->GetNetworkState(
+          service_path);
+  if (!network)
+    return std::string();
+  return network->name();
+}
+
 }  // namespace
 
 namespace chromeos {
 
-AppLaunchSplashScreenHandler::AppLaunchSplashScreenHandler()
+AppLaunchSplashScreenHandler::AppLaunchSplashScreenHandler(
+      const scoped_refptr<NetworkStateInformer>& network_state_informer,
+      ErrorScreenActor* error_screen_actor)
     : BaseScreenHandler(kJsScreenPath),
       delegate_(NULL),
       show_on_init_(false),
-      state_(APP_LAUNCH_STATE_LOADING_AUTH_FILE) {
+      state_(APP_LAUNCH_STATE_LOADING_AUTH_FILE),
+      network_state_informer_(network_state_informer),
+      error_screen_actor_(error_screen_actor) {
+  network_state_informer_->AddObserver(this);
 }
 
 AppLaunchSplashScreenHandler::~AppLaunchSplashScreenHandler() {
+  network_state_informer_->RemoveObserver(this);
 }
 
 void AppLaunchSplashScreenHandler::DeclareLocalizedValues(
     LocalizedValuesBuilder* builder) {
 
   builder->Add("appStartMessage", IDS_APP_START_NETWORK_WAIT_MESSAGE);
   builder->Add("configureNetwork", IDS_APP_START_CONFIGURE_NETWORK);
 
   const string16 product_os_name =
       l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_OS_NAME);
@@ skipping 53 matching lines @@
 
 void AppLaunchSplashScreenHandler::UpdateAppLaunchState(AppLaunchState state) {
   if (state == state_)
     return;
 
   state_ = state;
   if (page_is_ready()) {
     SetLaunchText(
         l10n_util::GetStringUTF8(GetProgressMessageFromState(state_)));
   }
+  UpdateState(ErrorScreenActor::ERROR_REASON_UPDATE);
 }
 
 void AppLaunchSplashScreenHandler::SetDelegate(
     AppLaunchSplashScreenHandler::Delegate* delegate) {
   delegate_ = delegate;
 }
 
+void AppLaunchSplashScreenHandler::ShowNetworkConfigureUI() {
+  NetworkStateInformer::State state = network_state_informer_->state();
+  if (state == NetworkStateInformer::ONLINE) {
+    delegate_->OnNetworkStateChanged(true);
+    return;
+  }
+
+  const std::string network_path = network_state_informer_->network_path();
+  const std::string network_name = GetNetworkName(network_path);
+
+  error_screen_actor_->SetUIState(ErrorScreen::UI_STATE_KIOSK_MODE);
+  error_screen_actor_->AllowGuestSignin(false);
+  error_screen_actor_->AllowOfflineLogin(false);
+
+  switch (state) {
+    case NetworkStateInformer::CAPTIVE_PORTAL: {
+      error_screen_actor_->SetErrorState(
+          ErrorScreen::ERROR_STATE_PORTAL, network_name);
+      error_screen_actor_->FixCaptivePortal();
+
+      break;
+    }
+    case NetworkStateInformer::PROXY_AUTH_REQUIRED: {
+      error_screen_actor_->SetErrorState(
+          ErrorScreen::ERROR_STATE_PROXY, network_name);
+      break;
+    }
+    case NetworkStateInformer::OFFLINE: {
+      error_screen_actor_->SetErrorState(
+          ErrorScreen::ERROR_STATE_OFFLINE, network_name);
+      break;
+    }
+    default:
+      error_screen_actor_->SetErrorState(
+          ErrorScreen::ERROR_STATE_OFFLINE, network_name);
+      NOTREACHED();
+      break;
+  };
+
+  OobeUI::Screen screen = OobeUI::SCREEN_UNKNOWN;
+  OobeUI* oobe_ui = static_cast<OobeUI*>(web_ui()->GetController());
+  if (oobe_ui)
+    screen = oobe_ui->current_screen();
+
+  if (screen != OobeUI::SCREEN_ERROR_MESSAGE)
+    error_screen_actor_->Show(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH, NULL);
+}
+
+void AppLaunchSplashScreenHandler::OnNetworkReady() {
+  // Purposely leave blank because the online case is handled in UpdateState
+  // call below.
+}
+
+void AppLaunchSplashScreenHandler::UpdateState(
+    ErrorScreenActor::ErrorReason reason) {
+  if (!delegate_ ||
+      (state_ != APP_LAUNCH_STATE_PREPARING_NETWORK &&
+       state_ != APP_LAUNCH_STATE_NETWORK_WAIT_TIMEOUT)) {
+    return;
+  }
+
+  NetworkStateInformer::State state = network_state_informer_->state();
+  delegate_->OnNetworkStateChanged(state == NetworkStateInformer::ONLINE);
+}
+
 void AppLaunchSplashScreenHandler::PopulateAppInfo(
     base::DictionaryValue* out_info) {
   KioskAppManager::App app;
   KioskAppManager::Get()->GetApp(app_id_, &app);
 
   if (app.name.empty())
     app.name = l10n_util::GetStringUTF8(IDS_SHORT_PRODUCT_NAME);
 
   if (app.icon.isNull()) {
     app.icon = *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
@@ skipping 35 matching lines @@
 }
 
 void AppLaunchSplashScreenHandler::HandleCancelAppLaunch() {
   if (delegate_)
     delegate_->OnCancelAppLaunch();
   else
     LOG(WARNING) << "No delegate set to handle cancel app launch";
 }
 
 }  // namespace chromeos