kiosk: Network connectivity test during launch.

chrome/browser/chromeos/login/app_launch_controller.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/chromeos/login/app_launch_controller.h"
 
 #include "apps/shell_window_registry.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/time/time.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/app_session_lifetime.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/app_mode/startup_app_launcher.h"
 #include "chrome/browser/chromeos/login/login_display_host.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/oobe_display.h"
 #include "chrome/browser/chromeos/login/screens/error_screen_actor.h"
 #include "chrome/browser/chromeos/login/webui_login_view.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/login/app_launch_splash_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/base/network_change_notifier.h"
 
 namespace chromeos {
 
 namespace {
 
 // Application install splash screen minimum show time in milliseconds.
 const int kAppInstallSplashScreenMinTimeMS = 3000;
 
 }  // namespace
 
 // static
 bool AppLaunchController::skip_splash_wait_ = false;
 int AppLaunchController::network_wait_time_ = 10;
 base::Closure* AppLaunchController::network_timeout_callback_ = NULL;
-AppLaunchController::CanConfigureNetworkCallback*
+AppLaunchController::ReturnBoolCallback*
     AppLaunchController::can_configure_network_callback_ = NULL;
+AppLaunchController::ReturnBoolCallback*
+    AppLaunchController::need_owner_auth_to_configure_network_callback_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // AppLaunchController::AppWindowWatcher
 
 class AppLaunchController::AppWindowWatcher
     : public apps::ShellWindowRegistry::Observer {
  public:
   explicit AppWindowWatcher(AppLaunchController* controller)
     : controller_(controller),
       window_registry_(apps::ShellWindowRegistry::Get(controller->profile_)) {
@@ skipping 26 matching lines @@
 
 AppLaunchController::AppLaunchController(const std::string& app_id,
                                          LoginDisplayHost* host,
                                          OobeDisplay* oobe_display)
     : profile_(NULL),
       app_id_(app_id),
       host_(host),
       oobe_display_(oobe_display),
       app_launch_splash_screen_actor_(
           oobe_display_->GetAppLaunchSplashScreenActor()),
-      error_screen_actor_(oobe_display_->GetErrorScreenActor()),
       webui_visible_(false),
       launcher_ready_(false),
       waiting_for_network_(false),
       network_wait_timedout_(false),
       showing_network_dialog_(false),
       launch_splash_start_time_(0) {
-  signin_screen_.reset(new AppLaunchSigninScreen(
-     static_cast<OobeUI*>(oobe_display_), this));
 }
 
 AppLaunchController::~AppLaunchController() {
   app_launch_splash_screen_actor_->SetDelegate(NULL);
 }
 
 void AppLaunchController::StartAppLaunch() {
   DVLOG(1) << "Starting kiosk mode...";
 
   webui_visible_ = host_->GetWebUILoginView()->webui_visible();
   if (!webui_visible_) {
     registrar_.Add(this, chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                    content::NotificationService::AllSources());
   }
   launch_splash_start_time_ = base::TimeTicks::Now().ToInternalValue();
 
   // TODO(tengs): Add a loading profile app launch state.
   app_launch_splash_screen_actor_->SetDelegate(this);
   app_launch_splash_screen_actor_->Show(app_id_);
 
   kiosk_profile_loader_.reset(
       new KioskProfileLoader(KioskAppManager::Get(), app_id_, this));
   kiosk_profile_loader_->Start();
 }
 
+// static
 void AppLaunchController::SkipSplashWaitForTesting() {
   skip_splash_wait_ = true;
 }
 
+// static
 void AppLaunchController::SetNetworkWaitForTesting(int wait_time_secs) {
   network_wait_time_ = wait_time_secs;
 }
 
+// static
 void AppLaunchController::SetNetworkTimeoutCallbackForTesting(
     base::Closure* callback) {
   network_timeout_callback_ = callback;
 }
 
+// static
 void AppLaunchController::SetCanConfigureNetworkCallbackForTesting(
-    CanConfigureNetworkCallback* can_configure_network_callback) {
+    ReturnBoolCallback* can_configure_network_callback) {
   can_configure_network_callback_ = can_configure_network_callback;
 }
 
+// static
+void AppLaunchController::SetNeedOwnerAuthToConfigureNetworkCallbackForTesting(
+    ReturnBoolCallback* need_owner_auth_callback) {
+  need_owner_auth_to_configure_network_callback_ = need_owner_auth_callback;
+}
+
 void AppLaunchController::OnConfigureNetwork() {
   DCHECK(profile_);
   showing_network_dialog_ = true;
-  if (CanConfigureNetwork()) {
+  if (CanConfigureNetwork() && NeedOwnerAuthToConfigureNetwork()) {
+    signin_screen_.reset(new AppLaunchSigninScreen(
+       static_cast<OobeUI*>(oobe_display_), this));
     signin_screen_->Show();
   } else {
     // If kiosk mode was configured through enterprise policy, we may
     // not have an owner user.
     // TODO(tengs): We need to figure out the appropriate security meausres
     // for this case.
     NOTREACHED();
   }
 }
 
 void AppLaunchController::OnOwnerSigninSuccess() {
-  error_screen_actor_->SetErrorState(
-      ErrorScreen::ERROR_STATE_OFFLINE, std::string());
-  error_screen_actor_->SetUIState(ErrorScreen::UI_STATE_KIOSK_MODE);
-
-  error_screen_actor_->Show(OobeDisplay::SCREEN_APP_LAUNCH_SPLASH, NULL);
-
+  app_launch_splash_screen_actor_->ShowNetworkConfigureUI();
   signin_screen_.reset();
 }
 
 void AppLaunchController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, type);
   DCHECK(!webui_visible_);
   webui_visible_ = true;
   launch_splash_start_time_ = base::TimeTicks::Now().ToInternalValue();
   if (launcher_ready_)
     OnReadyToLaunch();
 }
 
 void AppLaunchController::OnCancelAppLaunch() {
   if (KioskAppManager::Get()->GetDisableBailoutShortcut())
     return;
 
   OnLaunchFailed(KioskAppLaunchError::USER_CANCEL);
 }
 
+void AppLaunchController::OnNetworkStateChanged(bool online) {
+  if (!waiting_for_network_)
+    return;
+
+  if (online)

[Tim Song, 2013/11/21 01:12:17]

If the network comes up automatically when the error screen is being shown,
OnNetworkStateChanged(true) will still be called, right? In this case, we need
to dismiss the error screen if it's still there.

[xiyuan, 2013/11/21 22:39:39]

Yes, this will be called when network state changes, regardless of whether we
are showing the error screen. |showing_network_dialog_| is set to true when
error screen (or owner signin screen) is shown. And it will be dismissed in
AppLaunchController::OnInstallingApp.

+    startup_app_launcher_->ContinueWithNetworkReady();
+  else
+    MaybeShowNetworkConfigureUI();
+}
+
 void AppLaunchController::OnProfileLoaded(Profile* profile) {
   DVLOG(1) << "Profile loaded... Starting app launch.";
   profile_ = profile;
 
   kiosk_profile_loader_.reset();
   startup_app_launcher_.reset(new StartupAppLauncher(profile_, app_id_));
   startup_app_launcher_->AddObserver(this);
   startup_app_launcher_->Initialize();
 }
 
 void AppLaunchController::OnProfileLoadFailed(
     KioskAppLaunchError::Error error) {
   OnLaunchFailed(error);
 }
 
 void AppLaunchController::CleanUp() {
   kiosk_profile_loader_.reset();
   startup_app_launcher_.reset();
 
   if (host_)
     host_->Finalize();
 }
 
 void AppLaunchController::OnNetworkWaitTimedout() {
   DCHECK(waiting_for_network_);
   LOG(WARNING) << "OnNetworkWaitTimedout... connection = "
                <<  net::NetworkChangeNotifier::GetConnectionType();
   network_wait_timedout_ = true;
 
-  if (CanConfigureNetwork()) {
-    app_launch_splash_screen_actor_->ToggleNetworkConfig(true);
-  } else {
-    app_launch_splash_screen_actor_->UpdateAppLaunchState(
-        AppLaunchSplashScreenActor::APP_LAUNCH_STATE_NETWORK_WAIT_TIMEOUT);
-  }
+  MaybeShowNetworkConfigureUI();
 
   if (network_timeout_callback_)
     network_timeout_callback_->Run();
 }
 
 void AppLaunchController::OnAppWindowCreated() {
   DVLOG(1) << "App window created, closing splash screen.";
   CleanUp();
 }
 
 bool AppLaunchController::CanConfigureNetwork() {

[Tim Song, 2013/11/21 01:12:17]

Won't this function always return true now?

[xiyuan, 2013/11/21 22:39:39]

Nope, it returns false for consumer kiosk mode without an owner. I'll add a
comment to wire with device policy when its ready here.

   if (can_configure_network_callback_)
     return can_configure_network_callback_->Run();
 
-  return !UserManager::Get()->GetOwnerEmail().empty();
+  return g_browser_process->browser_policy_connector()->IsEnterpriseManaged() ||
+         !UserManager::Get()->GetOwnerEmail().empty();
+}
+
+bool AppLaunchController::NeedOwnerAuthToConfigureNetwork() {
+  if (need_owner_auth_to_configure_network_callback_)
+    return need_owner_auth_to_configure_network_callback_->Run();
+
+  return !g_browser_process->browser_policy_connector()->IsEnterpriseManaged();
+}
+
+void AppLaunchController::MaybeShowNetworkConfigureUI() {
+  if (CanConfigureNetwork()) {
+    if (NeedOwnerAuthToConfigureNetwork()) {
+      app_launch_splash_screen_actor_->ToggleNetworkConfig(true);
+     } else {

[Tim Song, 2013/11/21 01:12:17]

indent

[xiyuan, 2013/11/21 22:39:39]

Done.

+      showing_network_dialog_ = true;
+      app_launch_splash_screen_actor_->ShowNetworkConfigureUI();

[Tim Song, 2013/11/21 01:12:17]

Do we want to show the network UI immediately? One of the reasons for showing
the "Configure Network" button is so we can have a more aggressive time out
without severely disrupting the flow of the splash screen.

[xiyuan, 2013/11/21 22:39:39]

I can understand not showing up the owner signin screen automatically because
that would feel strange. But for error screen, I don't think it's too
disruptive. It's actually better because it saves user one click.

+     }
+  } else {
+    app_launch_splash_screen_actor_->UpdateAppLaunchState(
+        AppLaunchSplashScreenActor::APP_LAUNCH_STATE_NETWORK_WAIT_TIMEOUT);
+  }
 }
 
 void AppLaunchController::OnLoadingOAuthFile() {
   app_launch_splash_screen_actor_->UpdateAppLaunchState(
       AppLaunchSplashScreenActor::APP_LAUNCH_STATE_LOADING_AUTH_FILE);
 }
 
 void AppLaunchController::OnInitializingTokenService() {
   app_launch_splash_screen_actor_->UpdateAppLaunchState(
       AppLaunchSplashScreenActor::APP_LAUNCH_STATE_LOADING_TOKEN_SERVICE);
 }
 
 void AppLaunchController::OnInitializingNetwork() {
-  app_launch_splash_screen_actor_->UpdateAppLaunchState(
-      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_PREPARING_NETWORK);
-
   // Show the network configration dialog if network is not initialized
   // after a brief wait time.
   waiting_for_network_ = true;
   network_wait_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(network_wait_time_),
       this, &AppLaunchController::OnNetworkWaitTimedout);
+
+  app_launch_splash_screen_actor_->UpdateAppLaunchState(
+      AppLaunchSplashScreenActor::APP_LAUNCH_STATE_PREPARING_NETWORK);
 }
 
 void AppLaunchController::OnInstallingApp() {
   app_launch_splash_screen_actor_->UpdateAppLaunchState(
       AppLaunchSplashScreenActor::APP_LAUNCH_STATE_INSTALLING_APPLICATION);
 
+  waiting_for_network_ = false;
   network_wait_timer_.Stop();
   app_launch_splash_screen_actor_->ToggleNetworkConfig(false);
 
   // We have connectivity at this point, so we can skip the network
   // configuration dialog if it is being shown.
   if (showing_network_dialog_) {
     app_launch_splash_screen_actor_->Show(app_id_);
     showing_network_dialog_ = false;
     launch_splash_start_time_ = base::TimeTicks::Now().ToInternalValue();
   }
@@ skipping 36 matching lines @@
   LOG(ERROR) << "Kiosk launch failed. Will now shut down.";
   DCHECK_NE(KioskAppLaunchError::NONE, error);
 
   // Saves the error and ends the session to go back to login screen.
   KioskAppLaunchError::Save(error);
   chrome::AttemptUserExit();
   CleanUp();
 }
 
 }   // namespace chromeos