Added shortcut for NW config screen in kiosk.

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"
@@ skipping 25 matching lines @@
 namespace chromeos {
 
 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),
       network_state_informer_(network_state_informer),
-      error_screen_actor_(error_screen_actor) {
+      error_screen_actor_(error_screen_actor),
+      online_state_(false),
+      network_config_done_(false),
+      network_config_requested_(false) {
   network_state_informer_->AddObserver(this);
 }
 
 AppLaunchSplashScreenHandler::~AppLaunchSplashScreenHandler() {
   network_state_informer_->RemoveObserver(this);
 }
 
 void AppLaunchSplashScreenHandler::DeclareLocalizedValues(
     LocalizedValuesBuilder* builder) {
 
@@ skipping 37 matching lines @@
 
   SetLaunchText(l10n_util::GetStringUTF8(GetProgressMessageFromState(state_)));
   ShowScreen(OobeUI::kScreenAppLaunchSplash, &data);
 }
 
 void AppLaunchSplashScreenHandler::RegisterMessages() {
   AddCallback("configureNetwork",
               &AppLaunchSplashScreenHandler::HandleConfigureNetwork);
   AddCallback("cancelAppLaunch",
               &AppLaunchSplashScreenHandler::HandleCancelAppLaunch);
+  AddCallback("continueAppLaunch",
+              &AppLaunchSplashScreenHandler::HandleContinueAppLaunch);
+  AddCallback("networkConfigRequest",
+              &AppLaunchSplashScreenHandler::HandleNetworkConfigRequested);
 }
 
 void AppLaunchSplashScreenHandler::PrepareToShow() {
 }
 
 void AppLaunchSplashScreenHandler::Hide() {
 }
 
 void AppLaunchSplashScreenHandler::ToggleNetworkConfig(bool visible) {
   CallJS("toggleNetworkConfig", visible);
@@ skipping 12 matching lines @@
 }
 
 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;
+    online_state_ = true;
+    if (!network_config_requested_) {
+      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;
     }
+    case NetworkStateInformer::ONLINE: {
+      error_screen_actor_->SetErrorState(
+          ErrorScreen::ERROR_STATE_KIOSK_ONLINE, 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)
@@ skipping 13 matching lines @@
 }
 
 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);
+  bool new_online_state =
+      network_state_informer_->state() == NetworkStateInformer::ONLINE;
+  delegate_->OnNetworkStateChanged(new_online_state);
+
+  online_state_ = new_online_state;
 }
 
 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);
 
@@ skipping 36 matching lines @@
     LOG(WARNING) << "No delegate set to handle network configuration.";
 }
 
 void AppLaunchSplashScreenHandler::HandleCancelAppLaunch() {
   if (delegate_)
     delegate_->OnCancelAppLaunch();
   else
     LOG(WARNING) << "No delegate set to handle cancel app launch";
 }
 
+void AppLaunchSplashScreenHandler::HandleNetworkConfigRequested() {
+  if (!delegate_ || network_config_done_)
+    return;
+
+  network_config_requested_ = true;
+  delegate_->OnNetworkConfigRequested(true);
+}
+
+void AppLaunchSplashScreenHandler::HandleContinueAppLaunch() {
+  DCHECK(online_state_);
+  if (delegate_ && online_state_) {
+    network_config_requested_ = false;
+    network_config_done_ = true;
+    delegate_->OnNetworkConfigRequested(false);
+    Show(app_id_);
+  }
+}
+
 }  // namespace chromeos