Migrate (Network)ErrorScreen to ScreenContext

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

 // Copyright (c) 2012 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/enrollment_screen_handler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/error_screens_histogram_helper.h"
+#include "chrome/browser/chromeos/login/screens/network_error.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/policy/enrollment_status_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/signin/gaia_auth_extension_loader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "components/login/localized_values_builder.h"
@@ skipping 49 matching lines @@
 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();
 }
 
 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) {
   return state == NetworkStateInformer::PROXY_AUTH_REQUIRED ||
-         reason == ErrorScreenActor::ERROR_REASON_PROXY_AUTH_CANCELLED ||
-         reason == ErrorScreenActor::ERROR_REASON_PROXY_CONNECTION_FAILED;
+         reason == NetworkError::ERROR_REASON_PROXY_AUTH_CANCELLED ||
+         reason == NetworkError::ERROR_REASON_PROXY_CONNECTION_FAILED;
 }
 
 }  // namespace
 
 // EnrollmentScreenHandler, public ------------------------------
 
 EnrollmentScreenHandler::EnrollmentScreenHandler(
     const scoped_refptr<NetworkStateInformer>& network_state_informer,
-    ErrorScreenActor* error_screen_actor)
+    NetworkErrorModel* network_error_model)
     : BaseScreenHandler(kJsScreenPath),
       controller_(NULL),
       show_on_init_(false),
       frame_error_(net::OK),
       first_show_(true),
       observe_network_failure_(false),
       network_state_informer_(network_state_informer),
-      error_screen_actor_(error_screen_actor),
+      network_error_model_(network_error_model),
       histogram_helper_(new ErrorScreensHistogramHelper("Enrollment")),
       auth_extension_(nullptr),
       weak_ptr_factory_(this) {
   set_async_assets_load_id(OobeUI::kScreenOobeEnrollment);
   DCHECK(network_state_informer_.get());
-  DCHECK(error_screen_actor_);
+  DCHECK(network_error_model_);
   network_state_informer_->AddObserver(this);
 
   if (chromeos::LoginDisplayHostImpl::default_host()) {
     chromeos::WebUILoginView* login_view =
         chromeos::LoginDisplayHostImpl::default_host()->GetWebUILoginView();
     if (login_view)
       login_view->AddFrameObserver(this);
   }
 }
 
@@ skipping 235 matching lines @@
     screen = oobe_ui->current_screen();
   return screen;
 }
 
 bool EnrollmentScreenHandler::IsOnEnrollmentScreen() const {
   return (GetCurrentScreen() == OobeUI::SCREEN_OOBE_ENROLLMENT);
 }
 
 bool EnrollmentScreenHandler::IsEnrollmentScreenHiddenByError() const {
   return (GetCurrentScreen() == OobeUI::SCREEN_ERROR_MESSAGE &&
-          error_screen_actor_->parent_screen() ==
+          network_error_model_->GetParentScreen() ==
               OobeUI::SCREEN_OOBE_ENROLLMENT);
 }
 
-void EnrollmentScreenHandler::UpdateState(
-    ErrorScreenActor::ErrorReason reason) {
+void EnrollmentScreenHandler::UpdateState(NetworkError::ErrorReason reason) {
   UpdateStateInternal(reason, false);
 }
 
 // TODO(rsorokin): This function is mostly copied from SigninScreenHandler and
 // should be refactored in the future.
 void EnrollmentScreenHandler::UpdateStateInternal(
-    ErrorScreenActor::ErrorReason reason,
+    NetworkError::ErrorReason reason,
     bool force_update) {
   if (!force_update && !IsOnEnrollmentScreen() &&
       !IsEnrollmentScreenHiddenByError()) {
     return;
   }
 
   if (!force_update && !observe_network_failure_)
     return;
 
   NetworkStateInformer::State state = network_state_informer_->state();
   const std::string network_path = network_state_informer_->network_path();
   const bool is_online = (state == NetworkStateInformer::ONLINE);
   const bool is_behind_captive_portal =
       (state == NetworkStateInformer::CAPTIVE_PORTAL);
   const bool is_frame_error =
       (frame_error() != net::OK) ||
-      (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR);
+      (reason == NetworkError::ERROR_REASON_FRAME_ERROR);
 
   LOG(WARNING) << "EnrollmentScreenHandler::UpdateState(): "
                << "state=" << NetworkStateInformer::StatusString(state) << ", "
-               << "reason=" << ErrorScreenActor::ErrorReasonString(reason);
+               << "reason=" << NetworkError::ErrorReasonString(reason);
 
   if (is_online || !is_behind_captive_portal)
-    error_screen_actor_->HideCaptivePortal();
+    network_error_model_->HideCaptivePortal();
 
   if (is_frame_error) {
     LOG(WARNING) << "Retry page load";
     // TODO(rsorokin): Too many consecutive reloads.
     CallJS("doReload");
   }
 
   if (!is_online || is_frame_error)
     SetupAndShowOfflineMessage(state, reason);
   else
     HideOfflineMessage(state, reason);
 }
 
 void EnrollmentScreenHandler::SetupAndShowOfflineMessage(
     NetworkStateInformer::State state,
-    ErrorScreenActor::ErrorReason reason) {
+    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);
   const bool is_frame_error =
       (frame_error() != net::OK) ||
-      (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR);
+      (reason == NetworkError::ERROR_REASON_FRAME_ERROR);
 
   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 (IsOnEnrollmentScreen() || (error_screen_actor_->error_state() !=
-                                   ErrorScreen::ERROR_STATE_PORTAL)) {
-      error_screen_actor_->FixCaptivePortal();
+    if (IsOnEnrollmentScreen() || (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_frame_error) {
-    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());
   }
 
   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_OOBE_ENROLLMENT,
-                              &params,
-                              base::Bind(&EnrollmentScreenHandler::DoShow,
-                                         weak_ptr_factory_.GetWeakPtr()));
-    histogram_helper_->OnErrorShow(error_screen_actor_->error_state());
+    network_error_model_->SetUIState(NetworkError::UI_STATE_SIGNIN);
+    network_error_model_->SetParentScreen(OobeUI::SCREEN_OOBE_ENROLLMENT);
+    network_error_model_->SetHideCallback(base::Bind(
+        &EnrollmentScreenHandler::DoShow, weak_ptr_factory_.GetWeakPtr()));
+    network_error_model_->Show();
+    histogram_helper_->OnErrorShow(network_error_model_->GetErrorState());
   }
 }
 
 void EnrollmentScreenHandler::HideOfflineMessage(
     NetworkStateInformer::State state,
-    ErrorScreenActor::ErrorReason reason) {
+    NetworkError::ErrorReason reason) {
   if (IsEnrollmentScreenHiddenByError())
-    error_screen_actor_->Hide();
+    network_error_model_->Hide();
   histogram_helper_->OnErrorHide();
 }
 
 void EnrollmentScreenHandler::OnFrameError(
     const std::string& frame_unique_name) {
   if (frame_unique_name == "oauth-enroll-signin-frame") {
     HandleFrameLoadingCompleted(net::ERR_FAILED);
   }
 }
 // EnrollmentScreenHandler, private -----------------------------
@@ skipping 20 matching lines @@
   controller_->OnRetry();
 }
 
 void EnrollmentScreenHandler::HandleFrameLoadingCompleted(int status) {
   const net::Error frame_error = static_cast<net::Error>(status);
   frame_error_ = frame_error;
 
   if (network_state_informer_->state() != NetworkStateInformer::ONLINE)
     return;
   if (frame_error_)
-    UpdateState(ErrorScreenActor::ERROR_REASON_FRAME_ERROR);
+    UpdateState(NetworkError::ERROR_REASON_FRAME_ERROR);
   else
-    UpdateState(ErrorScreenActor::ERROR_REASON_UPDATE);
+    UpdateState(NetworkError::ERROR_REASON_UPDATE);
 }
 
 void EnrollmentScreenHandler::ShowStep(const char* step) {
   CallJS("showStep", std::string(step));
 }
 
 void EnrollmentScreenHandler::ShowError(int message_id, bool retry) {
   ShowErrorMessage(l10n_util::GetStringUTF8(message_id), retry);
 }
 
@@ skipping 15 matching lines @@
       config_.mode == policy::EnrollmentConfig::MODE_SERVER_ADVERTISED ||
       config_.mode == policy::EnrollmentConfig::MODE_SERVER_FORCED;
   screen_data.SetInteger("learn_more_help_topic_id",
                          is_server_triggered_enrollment
                              ? kEnrollmentHelpTopicServerTriggered
                              : kEnrollmentHelpTopicRegular);
 
   ShowScreen(OobeUI::kScreenOobeEnrollment, &screen_data);
   if (first_show_) {
     first_show_ = false;
-    UpdateStateInternal(ErrorScreenActor::ERROR_REASON_UPDATE, true);
+    UpdateStateInternal(NetworkError::ERROR_REASON_UPDATE, true);
   }
   histogram_helper_->OnScreenShow();
 }
 
 }  // namespace chromeos