Migrate (Network)ErrorScreen to ScreenContext

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

 // Copyright (c) 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/signin_screen_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/shell.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/login/error_screens_histogram_helper.h"
 #include "chrome/browser/chromeos/login/hwid_checker.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
+#include "chrome/browser/chromeos/login/screens/network_error.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_display.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/consumer_management_service.h"
 #include "chrome/browser/chromeos/policy/consumer_management_stage.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
+#include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/native_window_delegate.h"
 #include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
@@ skipping 56 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CallOnReturn);
 };
 
 }  // namespace
 
 namespace chromeos {
 
 namespace {
 
 bool IsOnline(NetworkStateInformer::State state,
-              ErrorScreenActor::ErrorReason reason) {
+              NetworkError::ErrorReason reason) {
   return state == NetworkStateInformer::ONLINE &&
-      reason != ErrorScreenActor::ERROR_REASON_PORTAL_DETECTED &&
-      reason != ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT;
+         reason != NetworkError::ERROR_REASON_PORTAL_DETECTED &&
+         reason != NetworkError::ERROR_REASON_LOADING_TIMEOUT;
 }
 
 bool IsBehindCaptivePortal(NetworkStateInformer::State state,
-                           ErrorScreenActor::ErrorReason reason) {
+                           NetworkError::ErrorReason reason) {
   return state == NetworkStateInformer::CAPTIVE_PORTAL ||
-      reason == ErrorScreenActor::ERROR_REASON_PORTAL_DETECTED;
+         reason == NetworkError::ERROR_REASON_PORTAL_DETECTED;
 }
 
 bool IsProxyError(NetworkStateInformer::State state,
-                  ErrorScreenActor::ErrorReason reason,
+                  NetworkError::ErrorReason reason,
                   net::Error frame_error) {
   return state == NetworkStateInformer::PROXY_AUTH_REQUIRED ||
-      reason == ErrorScreenActor::ERROR_REASON_PROXY_AUTH_CANCELLED ||
-      reason == ErrorScreenActor::ERROR_REASON_PROXY_CONNECTION_FAILED ||
-      (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR &&
-       (frame_error == net::ERR_PROXY_CONNECTION_FAILED ||
-        frame_error == net::ERR_TUNNEL_CONNECTION_FAILED));
+         reason == NetworkError::ERROR_REASON_PROXY_AUTH_CANCELLED ||
+         reason == NetworkError::ERROR_REASON_PROXY_CONNECTION_FAILED ||
+         (reason == NetworkError::ERROR_REASON_FRAME_ERROR &&
+          (frame_error == net::ERR_PROXY_CONNECTION_FAILED ||
+           frame_error == net::ERR_TUNNEL_CONNECTION_FAILED));
 }
 
 bool IsSigninScreen(const OobeUI::Screen screen) {
   return screen == OobeUI::SCREEN_GAIA_SIGNIN ||
       screen == OobeUI::SCREEN_ACCOUNT_PICKER;
 }
 
-bool IsSigninScreenError(ErrorScreen::ErrorState error_state) {
-  return error_state == ErrorScreen::ERROR_STATE_PORTAL ||
-      error_state == ErrorScreen::ERROR_STATE_OFFLINE ||
-      error_state == ErrorScreen::ERROR_STATE_PROXY ||
-      error_state == ErrorScreen::ERROR_STATE_AUTH_EXT_TIMEOUT;
+bool IsSigninScreenError(NetworkError::ErrorState error_state) {
+  return error_state == NetworkError::ERROR_STATE_PORTAL ||
+         error_state == NetworkError::ERROR_STATE_OFFLINE ||
+         error_state == NetworkError::ERROR_STATE_PROXY ||
+         error_state == NetworkError::ERROR_STATE_AUTH_EXT_TIMEOUT;
 }
 
 // Returns network name by service path.
 std::string GetNetworkName(const std::string& service_path) {
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!network)
     return std::string();
   return network->name();
 }
@@ skipping 50 matching lines @@
 }
 
 void LoginScreenContext::Init() {
   oobe_ui_ = false;
 }
 
 // SigninScreenHandler implementation ------------------------------------------
 
 SigninScreenHandler::SigninScreenHandler(
     const scoped_refptr<NetworkStateInformer>& network_state_informer,
-    ErrorScreenActor* error_screen_actor,
+    NetworkErrorModel* network_error_model,
     CoreOobeActor* core_oobe_actor,
     GaiaScreenHandler* gaia_screen_handler)
     : ui_state_(UI_STATE_UNKNOWN),
       delegate_(NULL),
       native_window_delegate_(NULL),
       show_on_init_(false),
       oobe_ui_(false),
       is_account_picker_showing_first_time_(false),
       network_state_informer_(network_state_informer),
       webui_visible_(false),
       preferences_changed_delayed_(false),
-      error_screen_actor_(error_screen_actor),
+      network_error_model_(network_error_model),
       core_oobe_actor_(core_oobe_actor),
       is_first_update_state_call_(true),
       offline_login_active_(false),
       last_network_state_(NetworkStateInformer::UNKNOWN),
       has_pending_auth_ui_(false),
       caps_lock_enabled_(chromeos::input_method::InputMethodManager::Get()
                              ->GetImeKeyboard()
                              ->CapsLockIsEnabled()),
       gaia_screen_handler_(gaia_screen_handler),
       oobe_ui_observer_added_(false),
       histogram_helper_(new ErrorScreensHistogramHelper("Signin")),
       weak_factory_(this) {
   DCHECK(network_state_informer_.get());
-  DCHECK(error_screen_actor_);
+  DCHECK(network_error_model_);
   DCHECK(core_oobe_actor_);
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->SetSigninScreenHandler(this);
   network_state_informer_->AddObserver(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_NEEDED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_SUPPLIED,
@@ skipping 272 matching lines @@
     NativeWindowDelegate* native_window_delegate) {
   native_window_delegate_ = native_window_delegate;
 }
 
 void SigninScreenHandler::OnNetworkReady() {
   VLOG(1) << "OnNetworkReady() call.";
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->MaybePreloadAuthExtension();
 }
 
-void SigninScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
+void SigninScreenHandler::UpdateState(NetworkError::ErrorReason reason) {
   UpdateStateInternal(reason, false);
 }
 
 void SigninScreenHandler::SetFocusPODCallbackForTesting(
     base::Closure callback) {
   test_focus_pod_callback_ = callback;
 }
 
 // SigninScreenHandler, private: -----------------------------------------------
 
@@ skipping 44 matching lines @@
       ShowScreen(OobeUI::kScreenAccountPicker, params);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 // TODO(ygorshenin@): split this method into small parts.
 // TODO(ygorshenin@): move this logic to GaiaScreenHandler.
-void SigninScreenHandler::UpdateStateInternal(
-    ErrorScreenActor::ErrorReason reason,
-    bool force_update) {
+void SigninScreenHandler::UpdateStateInternal(NetworkError::ErrorReason reason,
+                                              bool force_update) {
   // Do nothing once user has signed in or sign in is in progress.
   // TODO(ygorshenin): We will end up here when processing network state
   // notification but no ShowSigninScreen() was called so delegate_ will be
   // NULL. Network state processing logic does not belong here.
   if (delegate_ &&
       (delegate_->IsUserSigninCompleted() || delegate_->IsSigninInProgress())) {
     return;
   }
 
   NetworkStateInformer::State state = network_state_informer_->state();
@@ skipping 38 matching lines @@
           connecting_closure_.callback(),
           base::TimeDelta::FromSeconds(kConnectingTimeoutSec));
     }
     return;
   }
   connecting_closure_.Cancel();
 
   const bool is_online = IsOnline(state, reason);
   const bool is_behind_captive_portal = IsBehindCaptivePortal(state, reason);
   const bool is_gaia_loading_timeout =
-      (reason == ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
+      (reason == NetworkError::ERROR_REASON_LOADING_TIMEOUT);
   const bool is_gaia_error =
       FrameError() != net::OK && FrameError() != net::ERR_NETWORK_CHANGED;
   const bool is_gaia_signin = IsGaiaVisible() || IsGaiaHiddenByError();
   const bool error_screen_should_overlay =
       !offline_login_active_ && IsGaiaVisible();
   const bool from_not_online_to_online_transition =
       is_online && last_network_state_ != NetworkStateInformer::ONLINE;
   last_network_state_ = state;
 
   CallOnReturn reload_gaia(base::Bind(
       &SigninScreenHandler::ReloadGaia, weak_factory_.GetWeakPtr(), true));
 
   if (is_online || !is_behind_captive_portal)
-    error_screen_actor_->HideCaptivePortal();
+    network_error_model_->HideCaptivePortal();
 
   // Hide offline message (if needed) and return if current screen is
   // not a Gaia frame.
   if (!is_gaia_signin) {
     if (!IsSigninScreenHiddenByError())
       HideOfflineMessage(state, reason);
     return;
   }
 
   // Reload frame if network state is changed from {!ONLINE} -> ONLINE state.
-  if (reason == ErrorScreenActor::ERROR_REASON_NETWORK_STATE_CHANGED &&
+  if (reason == NetworkError::ERROR_REASON_NETWORK_STATE_CHANGED &&
       from_not_online_to_online_transition) {
     // Schedules a immediate retry.
     LOG(WARNING) << "Retry frame load since network has been changed.";
     reload_gaia.ScheduleCall();
   }
 
-  if (reason == ErrorScreenActor::ERROR_REASON_PROXY_CONFIG_CHANGED &&
+  if (reason == NetworkError::ERROR_REASON_PROXY_CONFIG_CHANGED &&
       error_screen_should_overlay) {
     // Schedules a immediate retry.
     LOG(WARNING) << "Retry frameload since proxy settings has been changed.";
     reload_gaia.ScheduleCall();
   }
 
-  if (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR &&
+  if (reason == NetworkError::ERROR_REASON_FRAME_ERROR &&
       !IsProxyError(state, reason, FrameError())) {
     LOG(WARNING) << "Retry frame load due to reason: "
-                 << ErrorScreenActor::ErrorReasonString(reason);
+                 << NetworkError::ErrorReasonString(reason);
     reload_gaia.ScheduleCall();
   }
 
   if (is_gaia_loading_timeout) {
     LOG(WARNING) << "Retry frame load due to loading timeout.";
     reload_gaia.ScheduleCall();
   }
 
   if ((!is_online || is_gaia_loading_timeout || is_gaia_error) &&
       !offline_login_active_) {
     SetupAndShowOfflineMessage(state, reason);
   } else {
     HideOfflineMessage(state, reason);
   }
 }
 
 void SigninScreenHandler::SetupAndShowOfflineMessage(
-    NetworkStateInformer:: State state,
-    ErrorScreenActor::ErrorReason reason) {
+    NetworkStateInformer::State state,
+    NetworkError::ErrorReason reason) {
   const std::string network_path = network_state_informer_->network_path();
   const bool is_behind_captive_portal = IsBehindCaptivePortal(state, reason);
   const bool is_proxy_error = IsProxyError(state, reason, FrameError());
   const bool is_gaia_loading_timeout =
-      (reason == ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
+      (reason == NetworkError::ERROR_REASON_LOADING_TIMEOUT);
 
   if (is_proxy_error) {
-    error_screen_actor_->SetErrorState(ErrorScreen::ERROR_STATE_PROXY,
-                                       std::string());
+    network_error_model_->SetErrorState(NetworkError::ERROR_STATE_PROXY,
+                                        std::string());
   } else if (is_behind_captive_portal) {
     // Do not bother a user with obsessive captive portal showing. This
     // check makes captive portal being shown only once: either when error
     // screen is shown for the first time or when switching from another
     // error screen (offline, proxy).
-    if (IsGaiaVisible() ||
-        (error_screen_actor_->error_state() !=
-         ErrorScreen::ERROR_STATE_PORTAL)) {
-      error_screen_actor_->FixCaptivePortal();
+    if (IsGaiaVisible() || (network_error_model_->GetErrorState() !=
+                            NetworkError::ERROR_STATE_PORTAL)) {
+      network_error_model_->FixCaptivePortal();
     }
     const std::string network_name = GetNetworkName(network_path);
-    error_screen_actor_->SetErrorState(ErrorScreen::ERROR_STATE_PORTAL,
-                                       network_name);
+    network_error_model_->SetErrorState(NetworkError::ERROR_STATE_PORTAL,
+                                        network_name);
   } else if (is_gaia_loading_timeout) {
-    error_screen_actor_->SetErrorState(
-        ErrorScreen::ERROR_STATE_AUTH_EXT_TIMEOUT, std::string());
+    network_error_model_->SetErrorState(
+        NetworkError::ERROR_STATE_AUTH_EXT_TIMEOUT, std::string());
   } else {
-    error_screen_actor_->SetErrorState(ErrorScreen::ERROR_STATE_OFFLINE,
-                                       std::string());
+    network_error_model_->SetErrorState(NetworkError::ERROR_STATE_OFFLINE,
+                                        std::string());
   }
 
-  const bool guest_signin_allowed = IsGuestSigninAllowed() &&
-      IsSigninScreenError(error_screen_actor_->error_state());
-  error_screen_actor_->AllowGuestSignin(guest_signin_allowed);
+  const bool guest_signin_allowed =
+      IsGuestSigninAllowed() &&
+      IsSigninScreenError(network_error_model_->GetErrorState());
+  network_error_model_->AllowGuestSignin(guest_signin_allowed);
 
-  const bool offline_login_allowed = IsOfflineLoginAllowed() &&
-      IsSigninScreenError(error_screen_actor_->error_state()) &&
-      error_screen_actor_->error_state() !=
-      ErrorScreen::ERROR_STATE_AUTH_EXT_TIMEOUT;
-  error_screen_actor_->AllowOfflineLogin(offline_login_allowed);
+  const bool offline_login_allowed =
+      IsOfflineLoginAllowed() &&
+      IsSigninScreenError(network_error_model_->GetErrorState()) &&
+      network_error_model_->GetErrorState() !=
+          NetworkError::ERROR_STATE_AUTH_EXT_TIMEOUT;
+  network_error_model_->AllowOfflineLogin(offline_login_allowed);
 
   if (GetCurrentScreen() != OobeUI::SCREEN_ERROR_MESSAGE) {
-    base::DictionaryValue params;
-    const std::string network_type = network_state_informer_->network_type();
-    params.SetString("lastNetworkType", network_type);
-    error_screen_actor_->SetUIState(ErrorScreen::UI_STATE_SIGNIN);
-    error_screen_actor_->Show(OobeUI::SCREEN_GAIA_SIGNIN, &params);
-    histogram_helper_->OnErrorShow(error_screen_actor_->error_state());
+    network_error_model_->SetUIState(NetworkError::UI_STATE_SIGNIN);
+    network_error_model_->SetParentScreen(OobeUI::SCREEN_GAIA_SIGNIN);
+    network_error_model_->Show();
+    histogram_helper_->OnErrorShow(network_error_model_->GetErrorState());
   }
 }
 
-void SigninScreenHandler::HideOfflineMessage(
-    NetworkStateInformer::State state,
-    ErrorScreenActor::ErrorReason reason) {
+void SigninScreenHandler::HideOfflineMessage(NetworkStateInformer::State state,
+                                             NetworkError::ErrorReason reason) {
   if (!IsSigninScreenHiddenByError())
     return;
 
-  error_screen_actor_->Hide();
+  network_error_model_->Hide();
   histogram_helper_->OnErrorHide();
 
   // Forces a reload for Gaia screen on hiding error message.
   if (IsGaiaVisible() || IsGaiaHiddenByError())
     ReloadGaia(false);
 }
 
 void SigninScreenHandler::ReloadGaia(bool force_reload) {
   gaia_screen_handler_->ReloadGaia(force_reload);
 }
@@ skipping 410 matching lines @@
   }
 }
 
 void SigninScreenHandler::HandleUnlockOnLoginSuccess() {
   DCHECK(user_manager::UserManager::Get()->IsUserLoggedIn());
   if (ScreenLocker::default_screen_locker())
     ScreenLocker::default_screen_locker()->UnlockOnLoginSuccess();
 }
 
 void SigninScreenHandler::HandleShowLoadingTimeoutError() {
-  UpdateState(ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
+  UpdateState(NetworkError::ERROR_REASON_LOADING_TIMEOUT);
 }
 
 void SigninScreenHandler::HandleUpdateOfflineLogin(bool offline_login_active) {
   offline_login_active_ = offline_login_active;
 }
 
 void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
   SetUserInputMethod(user_id, ime_state_.get());
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
   ScreenlockBridge::Get()->SetFocusedUser(user_id);
@@ skipping 102 matching lines @@
       ui_state_ == UI_STATE_GAIA_SIGNIN;
 }
 
 bool SigninScreenHandler::IsGaiaHiddenByError() const {
   return IsSigninScreenHiddenByError() &&
       ui_state_ == UI_STATE_GAIA_SIGNIN;
 }
 
 bool SigninScreenHandler::IsSigninScreenHiddenByError() const {
   return (GetCurrentScreen() == OobeUI::SCREEN_ERROR_MESSAGE) &&
-      (IsSigninScreen(error_screen_actor_->parent_screen()));
+         (IsSigninScreen(network_error_model_->GetParentScreen()));
 }
 
 bool SigninScreenHandler::IsGuestSigninAllowed() const {
   CrosSettings* cros_settings = CrosSettings::Get();
   if (!cros_settings)
     return false;
   bool allow_guest;
   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
   return allow_guest;
 }
 
 bool SigninScreenHandler::IsOfflineLoginAllowed() const {
   CrosSettings* cros_settings = CrosSettings::Get();
   if (!cros_settings)
     return false;
 
   // Offline login is allowed only when user pods are hidden.
   bool show_pods;
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn, &show_pods);
   return !show_pods;
 }
 
 void SigninScreenHandler::OnShowAddUser() {
   is_account_picker_showing_first_time_ = false;
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->ShowGaiaAsync(is_enrolling_consumer_management_);
 }
 
-GaiaScreenHandler::FrameState SigninScreenHandler::FrameState() const {
-  DCHECK(gaia_screen_handler_);
-  return gaia_screen_handler_->frame_state();
-}
-
 net::Error SigninScreenHandler::FrameError() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos