Migrating UpdateScreen to ScreenContext

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 <stdlib.h>
 #include <sys/types.h>
 
@@ skipping 67 matching lines @@
 #include "components/pairing/bluetooth_host_pairing_controller.h"
 #include "components/pairing/shark_connection_listener.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_types.h"
 #include "ui/base/accelerators/accelerator.h"
 
 using content::BrowserThread;
 
 namespace {
-// If reboot didn't happen, ask user to reboot device manually.
-const int kWaitForRebootTimeSec = 3;
-
 // Interval in ms which is used for smooth screen showing.
 static int kShowDelayMs = 400;
 
 // Total timezone resolving process timeout.
 const unsigned int kResolveTimeZoneTimeoutSeconds = 60;
 
 // Stores the list of all screens that should be shown when resuming OOBE.
 const char *kResumableScreens[] = {
   chromeos::WizardController::kNetworkScreenName,
   chromeos::WizardController::kUpdateScreenName,
@@ skipping 86 matching lines @@
 bool WizardController::skip_post_login_screens_ = false;
 
 // static
 bool WizardController::zero_delay_enabled_ = false;
 
 ///////////////////////////////////////////////////////////////////////////////
 // WizardController, public:
 
 PrefService* WizardController::local_state_for_testing_ = NULL;
 
-WizardController::WizardController(chromeos::LoginDisplayHost* host,
-                                   chromeos::OobeDisplay* oobe_display)
+WizardController::WizardController(LoginDisplayHost* host,
+                                   OobeDisplay* oobe_display)
     : current_screen_(NULL),
       previous_screen_(NULL),
 #if defined(GOOGLE_CHROME_BUILD)
       is_official_build_(true),
 #else
       is_official_build_(false),
 #endif
       is_out_of_box_(false),
       host_(host),
       oobe_display_(oobe_display),
@@ skipping 64 matching lines @@
        first_screen_name == WizardController::kTestNoScreenName)) {
     first_screen_name_ = screen_pref;
   }
 
   AdvanceToScreen(first_screen_name_);
   if (!IsMachineHWIDCorrect() && !StartupUtils::IsDeviceRegistered() &&
       first_screen_name_.empty())
     ShowWrongHWIDScreen();
 }
 
-chromeos::ErrorScreen* WizardController::GetErrorScreen() {
-  return static_cast<chromeos::ErrorScreen*>(GetScreen(kErrorScreenName));
+ErrorScreen* WizardController::GetErrorScreen() {
+  return static_cast<ErrorScreen*>(GetScreen(kErrorScreenName));
 }
 
 BaseScreen* WizardController::CreateScreen(const std::string& screen_name) {
   if (screen_name == kNetworkScreenName) {
-    scoped_ptr<NetworkScreen> screen(new chromeos::NetworkScreen(
-        this, this, oobe_display_->GetNetworkView()));
+    scoped_ptr<NetworkScreen> screen(
+        new NetworkScreen(this, this, oobe_display_->GetNetworkView()));
     screen->Initialize(nullptr /* context */);
     return screen.release();
   } else if (screen_name == kErrorScreenName) {
-    return new chromeos::ErrorScreen(this,
-                                     oobe_display_->GetErrorScreenActor());
+    return new ErrorScreen(this, oobe_display_->GetErrorScreenActor());
   } else if (screen_name == kUpdateScreenName) {
-    chromeos::UpdateScreen* result =
-        new chromeos::UpdateScreen(this,
-                                   oobe_display_->GetUpdateScreenActor(),
-                                   remora_controller_.get());
-    result->SetRebootCheckDelay(kWaitForRebootTimeSec);
-    return result;
+    scoped_ptr<UpdateScreen> screen(new UpdateScreen(
+        this, oobe_display_->GetUpdateView(), remora_controller_.get()));
+    screen->Initialize(nullptr /* context */);
+    return screen.release();
   } else if (screen_name == kUserImageScreenName) {
-    return new chromeos::UserImageScreen(this,
-                                         oobe_display_->GetUserImageView());
+    return new UserImageScreen(this, oobe_display_->GetUserImageView());
   } else if (screen_name == kEulaScreenName) {
-    return new chromeos::EulaScreen(this, this, oobe_display_->GetEulaView());
+    return new EulaScreen(this, this, oobe_display_->GetEulaView());
   } else if (screen_name == kEnrollmentScreenName) {
-    return new chromeos::EnrollmentScreen(
-        this, oobe_display_->GetEnrollmentScreenActor());
+    return new EnrollmentScreen(this,
+                                oobe_display_->GetEnrollmentScreenActor());
   } else if (screen_name == kResetScreenName) {
-    return new chromeos::ResetScreen(this,
-                                     oobe_display_->GetResetScreenActor());
+    return new ResetScreen(this, oobe_display_->GetResetScreenActor());
   } else if (screen_name == kEnableDebuggingScreenName) {
-    return new chromeos::EnableDebuggingScreen(
-        this,
-        oobe_display_->GetEnableDebuggingScreenActor());
+    return new EnableDebuggingScreen(
+        this, oobe_display_->GetEnableDebuggingScreenActor());
   } else if (screen_name == kKioskEnableScreenName) {
-    return new chromeos::KioskEnableScreen(
-        this, oobe_display_->GetKioskEnableScreenActor());
+    return new KioskEnableScreen(this,
+                                 oobe_display_->GetKioskEnableScreenActor());
   } else if (screen_name == kKioskAutolaunchScreenName) {
-    return new chromeos::KioskAutolaunchScreen(
+    return new KioskAutolaunchScreen(
         this, oobe_display_->GetKioskAutolaunchScreenActor());
   } else if (screen_name == kTermsOfServiceScreenName) {
-    return new chromeos::TermsOfServiceScreen(
+    return new TermsOfServiceScreen(
         this, oobe_display_->GetTermsOfServiceScreenActor());
   } else if (screen_name == kWrongHWIDScreenName) {
-    return new chromeos::WrongHWIDScreen(
-        this, oobe_display_->GetWrongHWIDScreenActor());
+    return new WrongHWIDScreen(this, oobe_display_->GetWrongHWIDScreenActor());
   } else if (screen_name == kSupervisedUserCreationScreenName) {
-    return new chromeos::SupervisedUserCreationScreen(
+    return new SupervisedUserCreationScreen(
         this, oobe_display_->GetSupervisedUserCreationScreenActor());
   } else if (screen_name == kHIDDetectionScreenName) {
-    return new chromeos::HIDDetectionScreen(
-        this, oobe_display_->GetHIDDetectionScreenActor());
+    return new HIDDetectionScreen(this,
+                                  oobe_display_->GetHIDDetectionScreenActor());
   } else if (screen_name == kAutoEnrollmentCheckScreenName) {
-    return new chromeos::AutoEnrollmentCheckScreen(
+    return new AutoEnrollmentCheckScreen(
         this, oobe_display_->GetAutoEnrollmentCheckScreenActor());
   } else if (screen_name == kControllerPairingScreenName) {
     if (!shark_controller_) {
       shark_controller_.reset(
           new pairing_chromeos::BluetoothControllerPairingController());
     }
     return new ControllerPairingScreen(
         this,
         this,
         oobe_display_->GetControllerPairingScreenActor(),
         shark_controller_.get());
   } else if (screen_name == kHostPairingScreenName) {
     if (!remora_controller_) {
       remora_controller_.reset(
           new pairing_chromeos::BluetoothHostPairingController());
       remora_controller_->StartPairing();
     }
     return new HostPairingScreen(this,
                                  this,
                                  oobe_display_->GetHostPairingScreenActor(),
                                  remora_controller_.get());
   } else if (screen_name == kDeviceDisabledScreenName) {
-    return new chromeos::DeviceDisabledScreen(
+    return new DeviceDisabledScreen(
         this, oobe_display_->GetDeviceDisabledScreenActor());
   }
 
   return NULL;
 }
 
 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.
@@ skipping 278 matching lines @@
         "OOBE.BootToSignInCompleted",
         delta,
         base::TimeDelta::FromMilliseconds(10),
         base::TimeDelta::FromMinutes(30),
         100);
     time_oobe_started_ = base::Time();
   }
 
   // Launch browser and delete login host controller.
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&chromeos::LoginUtils::DoBrowserLaunch,
-                 base::Unretained(chromeos::LoginUtils::Get()),
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&LoginUtils::DoBrowserLaunch,
+                 base::Unretained(LoginUtils::Get()),
                  ProfileManager::GetActiveUserProfile(), host_));
   host_ = NULL;
 }
 
 void WizardController::OnUserImageSkipped() {
   OnUserImageSelected();
 }
 
 void WizardController::OnEnrollmentDone() {
   // If the enrollment screen was shown as part of OOBE, OOBE is considered
@@ skipping 252 matching lines @@
       } else {
         ShowNetworkScreen();
       }
     } else {
       ShowLoginScreen(LoginScreenContext());
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// WizardController, chromeos::BaseScreenDelegate overrides:
+// WizardController, BaseScreenDelegate overrides:
 void WizardController::OnExit(BaseScreen& /* screen */,
                               ExitCodes exit_code,
                               const ::login::ScreenContext* /* context */) {
   VLOG(1) << "Wizard screen exit code: " << exit_code;
   std::string previous_screen_id = current_screen_->GetName();
   if (IsOOBEStepToTrack(previous_screen_id)) {
     RecordUMAHistogramForOOBEStepCompletionTime(
         previous_screen_id,
         base::Time::Now() - screen_show_times_[previous_screen_id]);
   }
@@ skipping 240 matching lines @@
 
   if (timezone->status != TimeZoneResponseData::OK) {
     LOG(WARNING) << "Resolve TimeZone: failed to resolve timezone.";
     return;
   }
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   if (connector->IsEnterpriseManaged()) {
     std::string policy_timezone;
-    if (chromeos::CrosSettings::Get()->GetString(
-            chromeos::kSystemTimezonePolicy, &policy_timezone) &&
+    if (CrosSettings::Get()->GetString(kSystemTimezonePolicy,
+                                       &policy_timezone) &&
         !policy_timezone.empty()) {
       VLOG(1) << "Resolve TimeZone: TimeZone settings are overridden"
               << " by DevicePolicy.";
       return;
     }
   }
 
   if (!timezone->timeZoneId.empty()) {
     VLOG(1) << "Resolve TimeZone: setting timezone to '" << timezone->timeZoneId
             << "'";
 
-    chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
+    system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
         base::UTF8ToUTF16(timezone->timeZoneId));
   }
 }
 
 TimeZoneProvider* WizardController::GetTimezoneProvider() {
   if (!timezone_provider_) {
     timezone_provider_.reset(
         new TimeZoneProvider(g_browser_process->system_request_context(),
                              DefaultTimezoneProviderURL()));
   }
@@ skipping 82 matching lines @@
   }
 
   EnrollmentScreen* screen = EnrollmentScreen::Get(this);
   screen->SetParameters(effective_config, shark_controller_.get(),
                         remora_controller_.get());
   SetStatusAreaVisible(true);
   SetCurrentScreen(screen);
 }
 
 }  // namespace chromeos