cros: Use ScreenManager as a component instead of deriving WizardController from it

chrome/browser/chromeos/login/wizard_controller.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/chromeos/login/wizard_controller.h"
 
 #include <signal.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ skipping 233 matching lines @@
 
 // static
 bool WizardController::zero_delay_enabled_ = false;
 
 ///////////////////////////////////////////////////////////////////////////////
 // WizardController, public:
 
 PrefService* WizardController::local_state_for_testing_ = nullptr;
 
 WizardController::WizardController(LoginDisplayHost* host, OobeUI* oobe_ui)
-    : host_(host), oobe_ui_(oobe_ui), weak_factory_(this) {
+    : screen_manager_(this),
+      host_(host),
+      oobe_ui_(oobe_ui),
+      weak_factory_(this) {
   DCHECK(default_controller_ == nullptr);
   default_controller_ = this;
   if (!ash_util::IsRunningInMash()) {
     AccessibilityManager* accessibility_manager = AccessibilityManager::Get();
     CHECK(accessibility_manager);
     accessibility_subscription_ = accessibility_manager->RegisterCallback(
         base::Bind(&WizardController::OnAccessibilityStatusChanged,
                    base::Unretained(this)));
   } else {
     NOTIMPLEMENTED();
@@ skipping 86 matching lines @@
     ShowWrongHWIDScreen();
 }
 
 ErrorScreen* WizardController::GetErrorScreen() {
   return oobe_ui_->GetErrorScreen();
 }
 
 BaseScreen* WizardController::GetScreen(OobeScreen screen) {
   if (screen == OobeScreen::SCREEN_ERROR_MESSAGE)
     return GetErrorScreen();
-  return ScreenManager::GetScreen(screen);
+  return screen_manager_.GetScreen(screen);
 }
 
 BaseScreen* WizardController::CreateScreen(OobeScreen screen) {
   if (screen == OobeScreen::SCREEN_OOBE_NETWORK) {
     return new NetworkScreen(this, this, oobe_ui_->GetNetworkView());
   } else if (screen == OobeScreen::SCREEN_OOBE_UPDATE) {
     return new UpdateScreen(this, oobe_ui_->GetUpdateView(),
                             remora_controller_.get());
   } else if (screen == OobeScreen::SCREEN_USER_IMAGE_PICKER) {
     return new UserImageScreen(this, oobe_ui_->GetUserImageView());
@@ skipping 51 matching lines @@
                                     oobe_ui_->GetDeviceDisabledScreenView());
   }
 
   return nullptr;
 }
 
 void WizardController::ShowNetworkScreen() {
   VLOG(1) << "Showing network screen.";
   // Hide the status area initially; it only appears after OOBE first animates
   // in. Keep it visible if the user goes back to the existing network screen.
-  SetStatusAreaVisible(HasScreen(OobeScreen::SCREEN_OOBE_NETWORK));
+  SetStatusAreaVisible(
+      screen_manager_.HasScreen(OobeScreen::SCREEN_OOBE_NETWORK));
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_OOBE_NETWORK));
 
   // There are two possible screens where we listen to the incoming Bluetooth
   // connection request: the first one is the HID detection screen, which will
   // show up when there is no sufficient input devices. In this case, we just
   // keep the logic as it is today: always put the Bluetooth is discoverable
   // mode. The other place is the Network screen (here), which will show up when
   // there are input devices detected. In this case, we disable the Bluetooth by
   // default until the user explicitly enable it by pressing a key combo (Ctrl+
   // Alt+Shift+S).
@@ skipping 131 matching lines @@
 
 void WizardController::ShowWrongHWIDScreen() {
   VLOG(1) << "Showing wrong HWID screen.";
   SetStatusAreaVisible(false);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_WRONG_HWID));
 }
 
 void WizardController::ShowAutoEnrollmentCheckScreen() {
   VLOG(1) << "Showing Auto-enrollment check screen.";
   SetStatusAreaVisible(true);
-  AutoEnrollmentCheckScreen* screen = AutoEnrollmentCheckScreen::Get(this);
+  AutoEnrollmentCheckScreen* screen =
+      AutoEnrollmentCheckScreen::Get(screen_manager());
   if (retry_auto_enrollment_check_)
     screen->ClearState();
   screen->set_auto_enrollment_controller(host_->GetAutoEnrollmentController());
   SetCurrentScreen(screen);
 }
 
 void WizardController::ShowSupervisedUserCreationScreen() {
   VLOG(1) << "Showing Locally managed user creation screen screen.";
   SetStatusAreaVisible(true);
   SetCurrentScreen(GetScreen(OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW));
@@ skipping 290 matching lines @@
             true, base::Bind(&WizardController::StartOOBEUpdate,
                              weak_factory_.GetWeakPtr()));
   } else {
     StartOOBEUpdate();
   }
 }
 
 void WizardController::StartOOBEUpdate() {
   VLOG(1) << "StartOOBEUpdate";
   SetCurrentScreenSmooth(GetScreen(OobeScreen::SCREEN_OOBE_UPDATE), true);
-  UpdateScreen::Get(this)->StartNetworkCheck();
+  UpdateScreen::Get(screen_manager())->StartNetworkCheck();
 }
 
 void WizardController::StartTimezoneResolve() {
   geolocation_provider_.reset(new SimpleGeolocationProvider(
       g_browser_process->system_request_context(),
       SimpleGeolocationProvider::DefaultGeolocationProviderURL()));
   geolocation_provider_->RequestGeolocation(
       base::TimeDelta::FromSeconds(kResolveTimeZoneTimeoutSeconds),
       false /* send_wifi_geolocation_data */,
       false /* send_cellular_geolocation_data */,
@@ skipping 281 matching lines @@
   usage_statistics_reporting_ = val;
 }
 
 bool WizardController::GetUsageStatisticsReporting() const {
   return usage_statistics_reporting_;
 }
 
 void WizardController::SetHostNetwork() {
   if (!shark_controller_)
     return;
-  NetworkScreen* network_screen = NetworkScreen::Get(this);
+  NetworkScreen* network_screen = NetworkScreen::Get(screen_manager());
   std::string onc_spec;
   network_screen->GetConnectedWifiNetwork(&onc_spec);
   if (!onc_spec.empty())
     shark_controller_->SetHostNetwork(onc_spec);
 }
 
 void WizardController::SetHostConfiguration() {
   if (!shark_controller_)
     return;
-  NetworkScreen* network_screen = NetworkScreen::Get(this);
+  NetworkScreen* network_screen = NetworkScreen::Get(screen_manager());
   shark_controller_->SetHostConfiguration(
       true,  // Eula must be accepted before we get this far.
       network_screen->GetApplicationLocale(), network_screen->GetTimezone(),
       GetUsageStatisticsReporting(), network_screen->GetInputMethod());
 }
 
 void WizardController::ConfigureHostRequested(
     bool accepted_eula,
     const std::string& lang,
     const std::string& timezone,
     bool send_reports,
     const std::string& keyboard_layout) {
   VLOG(1) << "ConfigureHost locale=" << lang << ", timezone=" << timezone
           << ", keyboard_layout=" << keyboard_layout;
   if (accepted_eula)  // Always true.
     StartupUtils::MarkEulaAccepted();
   SetUsageStatisticsReporting(send_reports);
 
-  NetworkScreen* network_screen = NetworkScreen::Get(this);
+  NetworkScreen* network_screen = NetworkScreen::Get(screen_manager());
   network_screen->SetApplicationLocaleAndInputMethod(lang, keyboard_layout);
   network_screen->SetTimezone(timezone);
 
   // Don't block the OOBE update and the following enrollment process if there
   // is available and valid network already.
   const chromeos::NetworkState* network_state = chromeos::NetworkHandler::Get()
                                                     ->network_state_handler()
                                                     ->DefaultNetwork();
   if (NetworkAllowUpdate(network_state))
     InitiateOOBEUpdate();
 }
 
 void WizardController::AddNetworkRequested(const std::string& onc_spec) {
   remora_controller_->OnNetworkConnectivityChanged(
       pairing_chromeos::HostPairingController::CONNECTIVITY_CONNECTING);
 
-  NetworkScreen* network_screen = NetworkScreen::Get(this);
+  NetworkScreen* network_screen = NetworkScreen::Get(screen_manager());
   const chromeos::NetworkState* network_state = chromeos::NetworkHandler::Get()
                                                     ->network_state_handler()
                                                     ->DefaultNetwork();
 
   if (NetworkAllowUpdate(network_state)) {
     network_screen->CreateAndConnectNetworkFromOnc(
         onc_spec, base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
   } else {
     network_screen->CreateAndConnectNetworkFromOnc(
         onc_spec, base::Bind(&WizardController::OnSetHostNetworkSuccessful,
@@ skipping 244 matching lines @@
   // manual enrollment is taking place.
   policy::EnrollmentConfig effective_config = prescribed_enrollment_config_;
   if (!effective_config.should_enroll() ||
       (force_interactive && !effective_config.should_enroll_interactively())) {
     effective_config.mode =
         prescribed_enrollment_config_.management_domain.empty()
             ? policy::EnrollmentConfig::MODE_MANUAL
             : policy::EnrollmentConfig::MODE_MANUAL_REENROLLMENT;
   }
 
-  EnrollmentScreen* screen = EnrollmentScreen::Get(this);
+  EnrollmentScreen* screen = EnrollmentScreen::Get(screen_manager());
   screen->SetParameters(effective_config, shark_controller_.get());
   SetStatusAreaVisible(true);
   SetCurrentScreen(screen);
 }
 
 }  // namespace chromeos