1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "chrome/browser/chromeos/login/wizard_controller.h"
6 
7 #include <signal.h>
8 #include <stddef.h>
9 #include <stdlib.h>
10 #include <sys/types.h>
11 
12 #include <memory>
13 #include <string>
14 #include <utility>
15 #include <vector>
16 
17 #include "ash/public/cpp/ash_switches.h"
18 #include "base/bind.h"
19 #include "base/callback_helpers.h"
20 #include "base/command_line.h"
21 #include "base/json/json_string_value_serializer.h"
22 #include "base/location.h"
23 #include "base/logging.h"
24 #include "base/macros.h"
25 #include "base/metrics/histogram_macros.h"
26 #include "base/no_destructor.h"
27 #include "base/single_thread_task_runner.h"
28 #include "base/strings/utf_string_conversions.h"
29 #include "base/task/thread_pool.h"
30 #include "base/threading/thread_task_runner_handle.h"
31 #include "build/branding_buildflags.h"
32 #include "chrome/browser/browser_process.h"
33 #include "chrome/browser/browser_process_platform_part.h"
34 #include "chrome/browser/chrome_notification_types.h"
35 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
36 #include "chrome/browser/chromeos/app_mode/arc/arc_kiosk_app_manager.h"
37 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
38 #include "chrome/browser/chromeos/app_mode/web_app/web_kiosk_app_manager.h"
39 #include "chrome/browser/chromeos/arc/arc_util.h"
40 #include "chrome/browser/chromeos/customization/customization_document.h"
41 #include "chrome/browser/chromeos/login/configuration_keys.h"
42 #include "chrome/browser/chromeos/login/demo_mode/demo_session.h"
43 #include "chrome/browser/chromeos/login/demo_mode/demo_setup_controller.h"
44 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_check_screen.h"
45 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
46 #include "chrome/browser/chromeos/login/existing_user_controller.h"
47 #include "chrome/browser/chromeos/login/helper.h"
48 #include "chrome/browser/chromeos/login/hwid_checker.h"
49 #include "chrome/browser/chromeos/login/login_wizard.h"
50 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_utils.h"
51 #include "chrome/browser/chromeos/login/screens/active_directory_login_screen.h"
52 #include "chrome/browser/chromeos/login/screens/active_directory_password_change_screen.h"
53 #include "chrome/browser/chromeos/login/screens/app_downloading_screen.h"
54 #include "chrome/browser/chromeos/login/screens/arc_terms_of_service_screen.h"
55 #include "chrome/browser/chromeos/login/screens/assistant_optin_flow_screen.h"
56 #include "chrome/browser/chromeos/login/screens/base_screen.h"
57 #include "chrome/browser/chromeos/login/screens/demo_preferences_screen.h"
58 #include "chrome/browser/chromeos/login/screens/demo_setup_screen.h"
59 #include "chrome/browser/chromeos/login/screens/device_disabled_screen.h"
60 #include "chrome/browser/chromeos/login/screens/edu_coexistence_login_screen.h"
61 #include "chrome/browser/chromeos/login/screens/enable_adb_sideloading_screen.h"
62 #include "chrome/browser/chromeos/login/screens/enable_debugging_screen.h"
63 #include "chrome/browser/chromeos/login/screens/encryption_migration_screen.h"
64 #include "chrome/browser/chromeos/login/screens/error_screen.h"
65 #include "chrome/browser/chromeos/login/screens/eula_screen.h"
66 #include "chrome/browser/chromeos/login/screens/family_link_notice_screen.h"
67 #include "chrome/browser/chromeos/login/screens/fingerprint_setup_screen.h"
68 #include "chrome/browser/chromeos/login/screens/gaia_password_changed_screen.h"
69 #include "chrome/browser/chromeos/login/screens/gaia_screen.h"
70 #include "chrome/browser/chromeos/login/screens/gesture_navigation_screen.h"
71 #include "chrome/browser/chromeos/login/screens/hid_detection_screen.h"
72 #include "chrome/browser/chromeos/login/screens/kiosk_autolaunch_screen.h"
73 #include "chrome/browser/chromeos/login/screens/kiosk_enable_screen.h"
74 #include "chrome/browser/chromeos/login/screens/marketing_opt_in_screen.h"
75 #include "chrome/browser/chromeos/login/screens/multidevice_setup_screen.h"
76 #include "chrome/browser/chromeos/login/screens/network_error.h"
77 #include "chrome/browser/chromeos/login/screens/network_screen.h"
78 #include "chrome/browser/chromeos/login/screens/packaged_license_screen.h"
79 #include "chrome/browser/chromeos/login/screens/pin_setup_screen.h"
80 #include "chrome/browser/chromeos/login/screens/recommend_apps_screen.h"
81 #include "chrome/browser/chromeos/login/screens/reset_screen.h"
82 #include "chrome/browser/chromeos/login/screens/signin_fatal_error_screen.h"
83 #include "chrome/browser/chromeos/login/screens/supervision_transition_screen.h"
84 #include "chrome/browser/chromeos/login/screens/sync_consent_screen.h"
85 #include "chrome/browser/chromeos/login/screens/tpm_error_screen.h"
86 #include "chrome/browser/chromeos/login/screens/update_required_screen.h"
87 #include "chrome/browser/chromeos/login/screens/update_screen.h"
88 #include "chrome/browser/chromeos/login/screens/user_creation_screen.h"
89 #include "chrome/browser/chromeos/login/screens/welcome_screen.h"
90 #include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
91 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
92 #include "chrome/browser/chromeos/login/startup_utils.h"
93 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
94 #include "chrome/browser/chromeos/login/wizard_context.h"
95 #include "chrome/browser/chromeos/multidevice_setup/multidevice_setup_client_factory.h"
96 #include "chrome/browser/chromeos/net/delay_network_call.h"
97 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
98 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
99 #include "chrome/browser/chromeos/policy/enrollment_requisition_manager.h"
100 #include "chrome/browser/chromeos/settings/cros_settings.h"
101 #include "chrome/browser/chromeos/settings/stats_reporting_controller.h"
102 #include "chrome/browser/chromeos/system/device_disabling_manager.h"
103 #include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
104 #include "chrome/browser/chromeos/system/timezone_util.h"
105 #include "chrome/browser/lifetime/application_lifetime.h"
106 #include "chrome/browser/metrics/metrics_reporting_state.h"
107 #include "chrome/browser/policy/profile_policy_connector.h"
108 #include "chrome/browser/profiles/profile.h"
109 #include "chrome/browser/profiles/profile_manager.h"
110 #include "chrome/browser/ui/ash/login_screen_client.h"
111 #include "chrome/browser/ui/webui/chromeos/login/active_directory_login_screen_handler.h"
112 #include "chrome/browser/ui/webui/chromeos/login/active_directory_password_change_screen_handler.h"
113 #include "chrome/browser/ui/webui/chromeos/login/app_downloading_screen_handler.h"
114 #include "chrome/browser/ui/webui/chromeos/login/app_launch_splash_screen_handler.h"
115 #include "chrome/browser/ui/webui/chromeos/login/arc_terms_of_service_screen_handler.h"
116 #include "chrome/browser/ui/webui/chromeos/login/assistant_optin_flow_screen_handler.h"
117 #include "chrome/browser/ui/webui/chromeos/login/auto_enrollment_check_screen_handler.h"
118 #include "chrome/browser/ui/webui/chromeos/login/demo_preferences_screen_handler.h"
119 #include "chrome/browser/ui/webui/chromeos/login/demo_setup_screen_handler.h"
120 #include "chrome/browser/ui/webui/chromeos/login/device_disabled_screen_handler.h"
121 #include "chrome/browser/ui/webui/chromeos/login/enable_debugging_screen_handler.h"
122 #include "chrome/browser/ui/webui/chromeos/login/encryption_migration_screen_handler.h"
123 #include "chrome/browser/ui/webui/chromeos/login/enrollment_screen_handler.h"
124 #include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
125 #include "chrome/browser/ui/webui/chromeos/login/eula_screen_handler.h"
126 #include "chrome/browser/ui/webui/chromeos/login/family_link_notice_screen_handler.h"
127 #include "chrome/browser/ui/webui/chromeos/login/fingerprint_setup_screen_handler.h"
128 #include "chrome/browser/ui/webui/chromeos/login/gaia_password_changed_screen_handler.h"
129 #include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
130 #include "chrome/browser/ui/webui/chromeos/login/gesture_navigation_screen_handler.h"
131 #include "chrome/browser/ui/webui/chromeos/login/hid_detection_screen_handler.h"
132 #include "chrome/browser/ui/webui/chromeos/login/kiosk_autolaunch_screen_handler.h"
133 #include "chrome/browser/ui/webui/chromeos/login/kiosk_enable_screen_handler.h"
134 #include "chrome/browser/ui/webui/chromeos/login/marketing_opt_in_screen_handler.h"
135 #include "chrome/browser/ui/webui/chromeos/login/multidevice_setup_screen_handler.h"
136 #include "chrome/browser/ui/webui/chromeos/login/network_screen_handler.h"
137 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
138 #include "chrome/browser/ui/webui/chromeos/login/packaged_license_screen_handler.h"
139 #include "chrome/browser/ui/webui/chromeos/login/parental_handoff_screen_handler.h"
140 #include "chrome/browser/ui/webui/chromeos/login/pin_setup_screen_handler.h"
141 #include "chrome/browser/ui/webui/chromeos/login/recommend_apps_screen_handler.h"
142 #include "chrome/browser/ui/webui/chromeos/login/reset_screen_handler.h"
143 #include "chrome/browser/ui/webui/chromeos/login/signin_fatal_error_screen_handler.h"
144 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
145 #include "chrome/browser/ui/webui/chromeos/login/supervision_transition_screen_handler.h"
146 #include "chrome/browser/ui/webui/chromeos/login/sync_consent_screen_handler.h"
147 #include "chrome/browser/ui/webui/chromeos/login/terms_of_service_screen_handler.h"
148 #include "chrome/browser/ui/webui/chromeos/login/tpm_error_screen_handler.h"
149 #include "chrome/browser/ui/webui/chromeos/login/update_required_screen_handler.h"
150 #include "chrome/browser/ui/webui/chromeos/login/update_screen_handler.h"
151 #include "chrome/browser/ui/webui/chromeos/login/user_creation_screen_handler.h"
152 #include "chrome/browser/ui/webui/chromeos/login/welcome_screen_handler.h"
153 #include "chrome/browser/ui/webui/chromeos/login/wrong_hwid_screen_handler.h"
154 #include "chrome/browser/ui/webui/help/help_utils_chromeos.h"
155 #include "chrome/common/chrome_constants.h"
156 #include "chrome/common/pref_names.h"
157 #include "chromeos/audio/cras_audio_handler.h"
158 #include "chromeos/constants/chromeos_constants.h"
159 #include "chromeos/constants/chromeos_switches.h"
160 #include "chromeos/constants/devicetype.h"
161 #include "chromeos/dbus/dbus_thread_manager.h"
162 #include "chromeos/dbus/session_manager/session_manager_client.h"
163 #include "chromeos/geolocation/simple_geolocation_provider.h"
164 #include "chromeos/network/network_handler.h"
165 #include "chromeos/network/network_handler_callbacks.h"
166 #include "chromeos/network/network_state.h"
167 #include "chromeos/network/network_state_handler.h"
168 #include "chromeos/network/portal_detector/network_portal_detector.h"
169 #include "chromeos/settings/cros_settings_names.h"
170 #include "chromeos/settings/cros_settings_provider.h"
171 #include "chromeos/settings/timezone_settings.h"
172 #include "chromeos/timezone/timezone_provider.h"
173 #include "chromeos/timezone/timezone_request.h"
174 #include "components/arc/arc_prefs.h"
175 #include "components/arc/arc_util.h"
176 #include "components/arc/session/arc_bridge_service.h"
177 #include "components/crash/core/app/breakpad_linux.h"
178 #include "components/crash/core/app/crashpad.h"
179 #include "components/prefs/pref_registry_simple.h"
180 #include "components/prefs/pref_service.h"
181 #include "components/session_manager/core/session_manager.h"
182 #include "components/user_manager/user_manager.h"
183 #include "content/public/browser/browser_task_traits.h"
184 #include "content/public/browser/browser_thread.h"
185 #include "content/public/browser/notification_types.h"
186 #include "services/network/public/cpp/shared_url_loader_factory.h"
187 #include "services/service_manager/public/cpp/connector.h"
188 #include "third_party/cros_system_api/dbus/service_constants.h"
189 #include "ui/base/accelerators/accelerator.h"
190 
191 using content::BrowserThread;
192 
193 namespace {
194 
195 bool g_using_zero_delays = false;
196 
197 // Total timezone resolving process timeout.
198 const unsigned int kResolveTimeZoneTimeoutSeconds = 60;
199 
200 constexpr const char kDefaultExitReason[] = "Next";
201 constexpr const char kResetScreenExitReason[] = "Cancel";
202 
203 // TODO(https://crbug.com/1161535) Remove after stepping stone is set after M87.
204 constexpr char kLegacyUpdateScreenName[] = "update";
205 
206 // Stores the list of all screens that should be shown when resuming OOBE.
207 const chromeos::StaticOobeScreenId kResumableScreens[] = {
208     chromeos::WelcomeView::kScreenId,
209     chromeos::NetworkScreenView::kScreenId,
210     chromeos::UpdateView::kScreenId,
211     chromeos::EulaView::kScreenId,
212     chromeos::EnrollmentScreenView::kScreenId,
213     chromeos::TermsOfServiceScreenView::kScreenId,
214     chromeos::SyncConsentScreenView::kScreenId,
215     chromeos::FingerprintSetupScreenView::kScreenId,
216     chromeos::GestureNavigationScreenView::kScreenId,
217     chromeos::ArcTermsOfServiceScreenView::kScreenId,
218     chromeos::AutoEnrollmentCheckScreenView::kScreenId,
219     chromeos::RecommendAppsScreenView::kScreenId,
220     chromeos::AppDownloadingScreenView::kScreenId,
221     chromeos::PinSetupScreenView::kScreenId,
222     chromeos::MarketingOptInScreenView::kScreenId,
223     chromeos::MultiDeviceSetupScreenView::kScreenId,
224 };
225 
226 const chromeos::StaticOobeScreenId kScreensWithHiddenStatusArea[] = {
227     chromeos::EnableAdbSideloadingScreenView::kScreenId,
228     chromeos::EnableDebuggingScreenView::kScreenId,
229     chromeos::KioskAutolaunchScreenView::kScreenId,
230     chromeos::KioskEnableScreenView::kScreenId,
231     chromeos::SupervisionTransitionScreenView::kScreenId,
232     chromeos::TpmErrorView::kScreenId,
233     chromeos::WrongHWIDScreenView::kScreenId,
234 };
235 
236 // The HID detection screen is only allowed for form factors without built-in
237 // inputs: Chromebases, Chromebits, and Chromeboxes (crbug.com/965765).
CanShowHIDDetectionScreen()238 bool CanShowHIDDetectionScreen() {
239   if (chromeos::StartupUtils::IsHIDDetectionScreenDisabledForTests())
240     return false;
241 
242   switch (chromeos::GetDeviceType()) {
243     case chromeos::DeviceType::kChromebase:
244     case chromeos::DeviceType::kChromebit:
245     case chromeos::DeviceType::kChromebox:
246       return !base::CommandLine::ForCurrentProcess()->HasSwitch(
247           chromeos::switches::kDisableHIDDetectionOnOOBEForTesting);
248     default:
249       return false;
250   }
251 }
252 
IsResumableScreen(chromeos::OobeScreenId screen_id)253 bool IsResumableScreen(chromeos::OobeScreenId screen_id) {
254   for (const auto& resumable_screen : kResumableScreens) {
255     if (screen_id == resumable_screen)
256       return true;
257   }
258   return false;
259 }
260 
ShouldHideStatusArea(chromeos::OobeScreenId screen_id)261 bool ShouldHideStatusArea(chromeos::OobeScreenId screen_id) {
262   for (const auto& s : kScreensWithHiddenStatusArea) {
263     if (screen_id == s)
264       return true;
265   }
266   return false;
267 }
268 
269 struct Entry {
270   chromeos::StaticOobeScreenId screen;
271   const char* uma_name;
272 };
273 
274 // Some screens had multiple different names in the past (they have since been
275 // unified). We need to always use the same name for UMA stats, though.
276 constexpr const Entry kLegacyUmaOobeScreenNames[] = {
277     {chromeos::ArcTermsOfServiceScreenView::kScreenId, "arc_tos"},
278     {chromeos::EnrollmentScreenView::kScreenId, "enroll"},
279     {chromeos::WelcomeView::kScreenId, "network"},
280     {chromeos::OobeScreen::SCREEN_CREATE_SUPERVISED_USER_FLOW_DEPRECATED,
281      "supervised-user-creation-flow"},
282     {chromeos::TermsOfServiceScreenView::kScreenId, "tos"}};
283 
RecordUMAHistogramForOOBEStepCompletionTime(chromeos::OobeScreenId screen,const std::string & exit_reason,base::TimeDelta step_time)284 void RecordUMAHistogramForOOBEStepCompletionTime(chromeos::OobeScreenId screen,
285                                                  const std::string& exit_reason,
286                                                  base::TimeDelta step_time) {
287   // Fetch screen name; make sure to use initial UMA name if the name has
288   // changed.
289   std::string screen_name = screen.name;
290   for (const auto& entry : kLegacyUmaOobeScreenNames) {
291     if (entry.screen.AsId() == screen) {
292       screen_name = entry.uma_name;
293       break;
294     }
295   }
296 
297   screen_name[0] = std::toupper(screen_name[0]);
298   std::string histogram_name = "OOBE.StepCompletionTime." + screen_name;
299 
300   // Equivalent to using UMA_HISTOGRAM_MEDIUM_TIMES. UMA_HISTOGRAM_MEDIUM_TIMES
301   // can not be used here, because `histogram_name` is calculated dynamically
302   // and changes from call to call.
303   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
304       histogram_name, base::TimeDelta::FromMilliseconds(10),
305       base::TimeDelta::FromMinutes(3), 50,
306       base::HistogramBase::kUmaTargetedHistogramFlag);
307   histogram->AddTime(step_time);
308 
309   // Use for this Histogram real screen names.
310   screen_name = screen.name;
311   screen_name[0] = std::toupper(screen_name[0]);
312   std::string histogram_name_with_reason =
313       "OOBE.StepCompletionTimeByExitReason." + screen_name + "." + exit_reason;
314   base::HistogramBase* histogram_with_reason = base::Histogram::FactoryTimeGet(
315       histogram_name_with_reason, base::TimeDelta::FromMilliseconds(10),
316       base::TimeDelta::FromMinutes(10), 100,
317       base::HistogramBase::kUmaTargetedHistogramFlag);
318   histogram_with_reason->AddTime(step_time);
319 }
320 
GetLoginDisplayHost()321 chromeos::LoginDisplayHost* GetLoginDisplayHost() {
322   return chromeos::LoginDisplayHost::default_host();
323 }
324 
GetOobeUI()325 chromeos::OobeUI* GetOobeUI() {
326   auto* host = chromeos::LoginDisplayHost::default_host();
327   return host ? host->GetOobeUI() : nullptr;
328 }
329 
330 scoped_refptr<network::SharedURLLoaderFactory>&
GetSharedURLLoaderFactoryForTesting()331 GetSharedURLLoaderFactoryForTesting() {
332   static base::NoDestructor<scoped_refptr<network::SharedURLLoaderFactory>>
333       loader;
334   return *loader;
335 }
336 
PrefToScreenId(const std::string & pref_value)337 chromeos::OobeScreenId PrefToScreenId(const std::string& pref_value) {
338   if (pref_value == kLegacyUpdateScreenName)
339     return chromeos::UpdateView::kScreenId;
340   return chromeos::OobeScreenId(pref_value);
341 }
342 
343 }  // namespace
344 
345 namespace chromeos {
346 
347 // static
348 const int WizardController::kMinAudibleOutputVolumePercent = 10;
349 
350 // static
351 bool WizardController::skip_post_login_screens_ = false;
352 
353 // static
354 bool WizardController::skip_enrollment_prompts_ = false;
355 
356 // static
357 #if BUILDFLAG(GOOGLE_CHROME_BRANDING)
358 bool WizardController::is_branded_build_ = true;
359 #else
360 bool WizardController::is_branded_build_ = false;
361 #endif
362 
363 // static
default_controller()364 WizardController* WizardController::default_controller() {
365   auto* host = chromeos::LoginDisplayHost::default_host();
366   return host ? host->GetWizardController() : nullptr;
367 }
368 
369 ///////////////////////////////////////////////////////////////////////////////
370 // WizardController, public:
371 
372 PrefService* WizardController::local_state_for_testing_ = nullptr;
373 
WizardController()374 WizardController::WizardController()
375     : screen_manager_(std::make_unique<ScreenManager>()),
376       wizard_context_(std::make_unique<WizardContext>()),
377       network_state_helper_(std::make_unique<login::NetworkStateHelper>()) {
378   AccessibilityManager* accessibility_manager = AccessibilityManager::Get();
379   if (accessibility_manager) {
380     // accessibility_manager could be null in Tests.
381     accessibility_subscription_ = accessibility_manager->RegisterCallback(
382         base::Bind(&WizardController::OnAccessibilityStatusChanged,
383                    weak_factory_.GetWeakPtr()));
384   }
385   if (GetOobeUI()) {
386     // could be null in unit tests.
387     screen_manager_->Init(CreateScreens());
388   }
389 }
390 
~WizardController()391 WizardController::~WizardController() {
392   for (ScreenObserver& obs : screen_observers_)
393     obs.OnShutdown();
394   screen_manager_.reset();
395 }
396 
Init(OobeScreenId first_screen)397 void WizardController::Init(OobeScreenId first_screen) {
398   DCHECK(!is_initialized());
399   is_initialized_ = true;
400 
401   prescribed_enrollment_config_ = g_browser_process->platform_part()
402                                       ->browser_policy_connector_chromeos()
403                                       ->GetPrescribedEnrollmentConfig();
404 
405   VLOG(1) << "Starting OOBE wizard with screen: " << first_screen;
406 
407   bool oobe_complete = StartupUtils::IsOobeCompleted();
408   if (!oobe_complete) {
409     UpdateOobeConfiguration();
410     is_out_of_box_ = true;
411   }
412 
413   wizard_context_->device_has_users =
414       !user_manager::UserManager::Get()->GetUsers().empty();
415 
416   // This is a hacky way to check for local state corruption, because
417   // it depends on the fact that the local state is loaded
418   // synchronously and at the first demand. IsEnterpriseManaged()
419   // check is required because currently powerwash is disabled for
420   // enterprise-enrolled devices.
421   //
422   // TODO (ygorshenin@): implement handling of the local state
423   // corruption in the case of asynchronious loading.
424   policy::BrowserPolicyConnectorChromeOS* connector =
425       g_browser_process->platform_part()->browser_policy_connector_chromeos();
426   const bool is_enterprise_managed = connector->IsEnterpriseManaged();
427   if (!is_enterprise_managed) {
428     const PrefService::PrefInitializationStatus status =
429         GetLocalState()->GetInitializationStatus();
430     if (status == PrefService::INITIALIZATION_STATUS_ERROR) {
431       OnLocalStateInitialized(false);
432       return;
433     }
434     if (status == PrefService::INITIALIZATION_STATUS_WAITING) {
435       GetLocalState()->AddPrefInitObserver(
436           base::BindOnce(&WizardController::OnLocalStateInitialized,
437                          weak_factory_.GetWeakPtr()));
438     }
439   }
440 
441   const bool device_is_owned =
442       is_enterprise_managed || wizard_context_->device_has_users;
443   // Do not show the HID Detection screen if device is owned.
444   if (!device_is_owned && CanShowHIDDetectionScreen() &&
445       first_screen == OobeScreen::SCREEN_UNKNOWN) {
446     base::Callback<void(bool)> on_check =
447         base::Bind(&WizardController::OnHIDScreenNecessityCheck,
448                    weak_factory_.GetWeakPtr());
449     GetScreen<HIDDetectionScreen>()->CheckIsScreenRequired(on_check);
450     return;
451   }
452 
453   AdvanceToScreenAfterHIDDetection(first_screen);
454 }
455 
AdvanceToScreenAfterHIDDetection(OobeScreenId first_screen)456 void WizardController::AdvanceToScreenAfterHIDDetection(
457     OobeScreenId first_screen) {
458   OobeScreenId actual_first_screen = first_screen;
459   if (actual_first_screen == OobeScreen::SCREEN_UNKNOWN) {
460     if (!is_out_of_box_) {
461       DeviceSettingsService::Get()->GetOwnershipStatusAsync(
462           base::Bind(&WizardController::OnOwnershipStatusCheckDone,
463                      weak_factory_.GetWeakPtr()));
464       return;
465     }
466 
467     // Use the saved screen preference from Local State.
468     const std::string screen_pref =
469         GetLocalState()->GetString(prefs::kOobeScreenPending);
470     if (!screen_pref.empty())
471       actual_first_screen = PrefToScreenId(screen_pref);
472     else
473       actual_first_screen = WelcomeView::kScreenId;
474   }
475 
476   first_screen_for_testing_ = actual_first_screen;
477   AdvanceToScreen(actual_first_screen);
478 
479   if (!IsMachineHWIDCorrect() && !StartupUtils::IsDeviceRegistered() &&
480       first_screen == OobeScreen::SCREEN_UNKNOWN) {
481     ShowWrongHWIDScreen();
482   }
483 
484   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
485           chromeos::switches::kOobeSkipToLogin)) {
486     SkipToLoginForTesting();
487   }
488 }
489 
GetErrorScreen()490 ErrorScreen* WizardController::GetErrorScreen() {
491   return GetOobeUI()->GetErrorScreen();
492 }
493 
HasScreen(OobeScreenId screen_id)494 bool WizardController::HasScreen(OobeScreenId screen_id) {
495   return screen_manager_->HasScreen(screen_id);
496 }
497 
GetScreen(OobeScreenId screen_id)498 BaseScreen* WizardController::GetScreen(OobeScreenId screen_id) {
499   if (screen_id == ErrorScreenView::kScreenId)
500     return GetErrorScreen();
501   return screen_manager_->GetScreen(screen_id);
502 }
503 
SetCurrentScreenForTesting(BaseScreen * screen)504 void WizardController::SetCurrentScreenForTesting(BaseScreen* screen) {
505   current_screen_ = screen;
506 }
507 
SetSharedURLLoaderFactoryForTesting(scoped_refptr<network::SharedURLLoaderFactory> factory)508 void WizardController::SetSharedURLLoaderFactoryForTesting(
509     scoped_refptr<network::SharedURLLoaderFactory> factory) {
510   auto& testing_factory = GetSharedURLLoaderFactoryForTesting();
511   testing_factory = std::move(factory);
512 }
513 
CreateScreens()514 std::vector<std::unique_ptr<BaseScreen>> WizardController::CreateScreens() {
515   OobeUI* oobe_ui = GetOobeUI();
516 
517   std::vector<std::unique_ptr<BaseScreen>> result;
518 
519   auto append = [&](std::unique_ptr<BaseScreen> screen) {
520     result.emplace_back(std::move(screen));
521   };
522 
523   if (oobe_ui->display_type() == OobeUI::kOobeDisplay) {
524     append(std::make_unique<WelcomeScreen>(
525         oobe_ui->GetView<WelcomeScreenHandler>(),
526         base::BindRepeating(&WizardController::OnWelcomeScreenExit,
527                             weak_factory_.GetWeakPtr())));
528 
529     append(std::make_unique<chromeos::DemoPreferencesScreen>(
530         oobe_ui->GetView<DemoPreferencesScreenHandler>(),
531         base::BindRepeating(&WizardController::OnDemoPreferencesScreenExit,
532                             weak_factory_.GetWeakPtr())));
533   }
534 
535   append(std::make_unique<NetworkScreen>(
536       oobe_ui->GetView<NetworkScreenHandler>(),
537       base::BindRepeating(&WizardController::OnNetworkScreenExit,
538                           weak_factory_.GetWeakPtr())));
539   append(std::make_unique<UpdateScreen>(
540       oobe_ui->GetView<UpdateScreenHandler>(), oobe_ui->GetErrorScreen(),
541       base::BindRepeating(&WizardController::OnUpdateScreenExit,
542                           weak_factory_.GetWeakPtr())));
543   append(std::make_unique<EulaScreen>(
544       oobe_ui->GetView<EulaScreenHandler>(),
545       base::BindRepeating(&WizardController::OnEulaScreenExit,
546                           weak_factory_.GetWeakPtr())));
547   append(std::make_unique<EnrollmentScreen>(
548       oobe_ui->GetView<EnrollmentScreenHandler>(),
549       base::BindRepeating(&WizardController::OnEnrollmentScreenExit,
550                           weak_factory_.GetWeakPtr())));
551   append(std::make_unique<chromeos::ResetScreen>(
552       oobe_ui->GetView<ResetScreenHandler>(), oobe_ui->GetErrorScreen(),
553       base::BindRepeating(&WizardController::OnResetScreenExit,
554                           weak_factory_.GetWeakPtr())));
555   append(std::make_unique<chromeos::DemoSetupScreen>(
556       oobe_ui->GetView<DemoSetupScreenHandler>(),
557       base::BindRepeating(&WizardController::OnDemoSetupScreenExit,
558                           weak_factory_.GetWeakPtr())));
559   append(std::make_unique<EnableAdbSideloadingScreen>(
560       oobe_ui->GetView<EnableAdbSideloadingScreenHandler>(),
561       base::BindRepeating(&WizardController::OnEnableAdbSideloadingScreenExit,
562                           weak_factory_.GetWeakPtr())));
563   append(std::make_unique<EnableDebuggingScreen>(
564       oobe_ui->GetView<EnableDebuggingScreenHandler>(),
565       base::BindRepeating(&WizardController::OnEnableDebuggingScreenExit,
566                           weak_factory_.GetWeakPtr())));
567   append(std::make_unique<KioskEnableScreen>(
568       oobe_ui->GetView<KioskEnableScreenHandler>(),
569       base::BindRepeating(&WizardController::OnKioskEnableScreenExit,
570                           weak_factory_.GetWeakPtr())));
571   append(std::make_unique<KioskAutolaunchScreen>(
572       oobe_ui->GetView<KioskAutolaunchScreenHandler>(),
573       base::BindRepeating(&WizardController::OnKioskAutolaunchScreenExit,
574                           weak_factory_.GetWeakPtr())));
575   append(std::make_unique<TermsOfServiceScreen>(
576       oobe_ui->GetView<TermsOfServiceScreenHandler>(),
577       base::BindRepeating(&WizardController::OnTermsOfServiceScreenExit,
578                           weak_factory_.GetWeakPtr())));
579   append(std::make_unique<SyncConsentScreen>(
580       oobe_ui->GetView<SyncConsentScreenHandler>(),
581       base::BindRepeating(&WizardController::OnSyncConsentScreenExit,
582                           weak_factory_.GetWeakPtr())));
583   append(std::make_unique<ArcTermsOfServiceScreen>(
584       oobe_ui->GetView<ArcTermsOfServiceScreenHandler>(),
585       base::BindRepeating(&WizardController::OnArcTermsOfServiceScreenExit,
586                           weak_factory_.GetWeakPtr())));
587   append(std::make_unique<RecommendAppsScreen>(
588       oobe_ui->GetView<RecommendAppsScreenHandler>(),
589       base::BindRepeating(&WizardController::OnRecommendAppsScreenExit,
590                           weak_factory_.GetWeakPtr())));
591   append(std::make_unique<AppDownloadingScreen>(
592       oobe_ui->GetView<AppDownloadingScreenHandler>(),
593       base::BindRepeating(&WizardController::OnAppDownloadingScreenExit,
594                           weak_factory_.GetWeakPtr())));
595   append(std::make_unique<WrongHWIDScreen>(
596       oobe_ui->GetView<WrongHWIDScreenHandler>(),
597       base::BindRepeating(&WizardController::OnWrongHWIDScreenExit,
598                           weak_factory_.GetWeakPtr())));
599 
600   if (CanShowHIDDetectionScreen()) {
601     append(std::make_unique<chromeos::HIDDetectionScreen>(
602         oobe_ui->GetView<HIDDetectionScreenHandler>(),
603         base::BindRepeating(&WizardController::OnHidDetectionScreenExit,
604                             weak_factory_.GetWeakPtr())));
605   }
606 
607   append(std::make_unique<AutoEnrollmentCheckScreen>(
608       oobe_ui->GetView<AutoEnrollmentCheckScreenHandler>(),
609       oobe_ui->GetErrorScreen(),
610       base::BindRepeating(&WizardController::OnAutoEnrollmentCheckScreenExit,
611                           weak_factory_.GetWeakPtr())));
612   append(std::make_unique<DeviceDisabledScreen>(
613       oobe_ui->GetView<DeviceDisabledScreenHandler>()));
614   append(std::make_unique<EncryptionMigrationScreen>(
615       oobe_ui->GetView<EncryptionMigrationScreenHandler>()));
616   append(std::make_unique<SupervisionTransitionScreen>(
617       oobe_ui->GetView<SupervisionTransitionScreenHandler>(),
618       base::BindRepeating(&WizardController::OnSupervisionTransitionScreenExit,
619                           weak_factory_.GetWeakPtr())));
620   append(std::make_unique<UpdateRequiredScreen>(
621       oobe_ui->GetView<UpdateRequiredScreenHandler>(),
622       oobe_ui->GetErrorScreen(),
623       base::BindRepeating(&WizardController::OnUpdateRequiredScreenExit,
624                           weak_factory_.GetWeakPtr())));
625   append(std::make_unique<AssistantOptInFlowScreen>(
626       oobe_ui->GetView<AssistantOptInFlowScreenHandler>(),
627       base::BindRepeating(&WizardController::OnAssistantOptInFlowScreenExit,
628                           weak_factory_.GetWeakPtr())));
629   append(std::make_unique<MultiDeviceSetupScreen>(
630       oobe_ui->GetView<MultiDeviceSetupScreenHandler>(),
631       base::BindRepeating(&WizardController::OnMultiDeviceSetupScreenExit,
632                           weak_factory_.GetWeakPtr())));
633   append(std::make_unique<PinSetupScreen>(
634       oobe_ui->GetView<PinSetupScreenHandler>(),
635       base::BindRepeating(&WizardController::OnPinSetupScreenExit,
636                           weak_factory_.GetWeakPtr())));
637   append(std::make_unique<FingerprintSetupScreen>(
638       oobe_ui->GetView<FingerprintSetupScreenHandler>(),
639       base::BindRepeating(&WizardController::OnFingerprintSetupScreenExit,
640                           weak_factory_.GetWeakPtr())));
641   append(std::make_unique<GestureNavigationScreen>(
642       oobe_ui->GetView<GestureNavigationScreenHandler>(),
643       base::BindRepeating(&WizardController::OnGestureNavigationScreenExit,
644                           weak_factory_.GetWeakPtr())));
645   append(std::make_unique<MarketingOptInScreen>(
646       oobe_ui->GetView<MarketingOptInScreenHandler>(),
647       base::BindRepeating(&WizardController::OnMarketingOptInScreenExit,
648                           weak_factory_.GetWeakPtr())));
649   append(std::make_unique<PackagedLicenseScreen>(
650       oobe_ui->GetView<PackagedLicenseScreenHandler>(),
651       base::BindRepeating(&WizardController::OnPackagedLicenseScreenExit,
652                           weak_factory_.GetWeakPtr())));
653   auto gaia_screen = std::make_unique<GaiaScreen>(base::BindRepeating(
654       &WizardController::OnGaiaScreenExit, weak_factory_.GetWeakPtr()));
655   gaia_screen->SetView(oobe_ui->GetView<GaiaScreenHandler>());
656   append(std::move(gaia_screen));
657 
658   append(std::make_unique<TpmErrorScreen>(
659       oobe_ui->GetView<TpmErrorScreenHandler>()));
660 
661   append(std::make_unique<GaiaPasswordChangedScreen>(
662       oobe_ui->GetView<GaiaPasswordChangedScreenHandler>()));
663 
664   append(std::make_unique<ActiveDirectoryPasswordChangeScreen>(
665       oobe_ui->GetView<ActiveDirectoryPasswordChangeScreenHandler>(),
666       base::BindRepeating(
667           &WizardController::OnActiveDirectoryPasswordChangeScreenExit,
668           weak_factory_.GetWeakPtr())));
669 
670   append(std::make_unique<FamilyLinkNoticeScreen>(
671       oobe_ui->GetView<FamilyLinkNoticeScreenHandler>(),
672       base::BindRepeating(&WizardController::OnFamilyLinkNoticeScreenExit,
673                           weak_factory_.GetWeakPtr())));
674 
675   append(std::make_unique<UserCreationScreen>(
676       oobe_ui->GetView<UserCreationScreenHandler>(), oobe_ui->GetErrorScreen(),
677       base::BindRepeating(&WizardController::OnUserCreationScreenExit,
678                           weak_factory_.GetWeakPtr())));
679 
680   append(std::make_unique<ActiveDirectoryLoginScreen>(
681       oobe_ui->GetView<ActiveDirectoryLoginScreenHandler>(),
682       oobe_ui->GetErrorScreen(),
683       base::BindRepeating(&WizardController::OnActiveDirectoryLoginScreenExit,
684                           weak_factory_.GetWeakPtr())));
685 
686   append(std::make_unique<EduCoexistenceLoginScreen>(
687       base::BindRepeating(&WizardController::OnEduCoexistenceLoginScreenExit,
688                           weak_factory_.GetWeakPtr())));
689 
690   append(std::make_unique<SignInFatalErrorScreen>(
691       oobe_ui->GetView<SignInFatalErrorScreenHandler>(),
692       base::BindRepeating(&WizardController::OnSignInFatalErrorScreenExit,
693                           weak_factory_.GetWeakPtr())));
694 
695   append(std::make_unique<ParentalHandoffScreen>(
696       oobe_ui->GetView<ParentalHandoffScreenHandler>(),
697       base::BindRepeating(&WizardController::OnParentalHandoffScreenExit,
698                           weak_factory_.GetWeakPtr())));
699 
700   return result;
701 }
702 
ShowWelcomeScreen()703 void WizardController::ShowWelcomeScreen() {
704   SetCurrentScreen(GetScreen(WelcomeView::kScreenId));
705 }
706 
ShowNetworkScreen()707 void WizardController::ShowNetworkScreen() {
708   SetCurrentScreen(GetScreen(NetworkScreenView::kScreenId));
709 }
710 
OnOwnershipStatusCheckDone(DeviceSettingsService::OwnershipStatus status)711 void WizardController::OnOwnershipStatusCheckDone(
712     DeviceSettingsService::OwnershipStatus status) {
713   if (status == DeviceSettingsService::OWNERSHIP_NONE)
714     ShowPackagedLicenseScreen();
715   else
716     ShowLoginScreen();
717 }
718 
ShowSignInFatalErrorScreen(SignInFatalErrorScreen::Error error,const base::Value * params)719 void WizardController::ShowSignInFatalErrorScreen(
720     SignInFatalErrorScreen::Error error,
721     const base::Value* params) {
722   GetScreen<SignInFatalErrorScreen>()->SetErrorState(error, params);
723   AdvanceToScreen(SignInFatalErrorView::kScreenId);
724 }
725 
OnSignInFatalErrorScreenExit()726 void WizardController::OnSignInFatalErrorScreenExit() {
727   OnScreenExit(SignInFatalErrorView::kScreenId, kDefaultExitReason);
728   AdvanceToScreen(GaiaView::kScreenId);
729 }
730 
ShowLoginScreen()731 void WizardController::ShowLoginScreen() {
732   // This may be triggered by multiply asynchronous events from the JS side.
733   if (login_screen_started_)
734     return;
735 
736   if (!time_eula_accepted_.is_null()) {
737     base::TimeDelta delta = base::TimeTicks::Now() - time_eula_accepted_;
738     UMA_HISTOGRAM_MEDIUM_TIMES("OOBE.EULAToSignInTime", delta);
739   }
740   VLOG(1) << "Showing login screen.";
741   UpdateStatusAreaVisibilityForScreen(GaiaView::kScreenId);
742   GetLoginDisplayHost()->StartSignInScreen();
743   login_screen_started_ = true;
744 }
745 
ShowGaiaPasswordChangedScreen(const AccountId & account_id,bool has_error)746 void WizardController::ShowGaiaPasswordChangedScreen(
747     const AccountId& account_id,
748     bool has_error) {
749   GaiaPasswordChangedScreen* screen = GetScreen<GaiaPasswordChangedScreen>();
750   screen->Configure(account_id, has_error);
751   if (current_screen_ != screen) {
752     SetCurrentScreen(screen);
753   } else {
754     screen->Show(wizard_context_.get());
755   }
756 }
757 
ShowEulaScreen()758 void WizardController::ShowEulaScreen() {
759   SetCurrentScreen(GetScreen(EulaView::kScreenId));
760 }
761 
ShowEnrollmentScreen()762 void WizardController::ShowEnrollmentScreen() {
763   // Update the enrollment configuration and start the screen.
764   prescribed_enrollment_config_ = g_browser_process->platform_part()
765                                       ->browser_policy_connector_chromeos()
766                                       ->GetPrescribedEnrollmentConfig();
767   StartEnrollmentScreen(false);
768 }
769 
ShowDemoModePreferencesScreen()770 void WizardController::ShowDemoModePreferencesScreen() {
771   SetCurrentScreen(GetScreen(DemoPreferencesScreenView::kScreenId));
772 }
773 
ShowDemoModeSetupScreen()774 void WizardController::ShowDemoModeSetupScreen() {
775   SetCurrentScreen(GetScreen(DemoSetupScreenView::kScreenId));
776 }
777 
ShowResetScreen()778 void WizardController::ShowResetScreen() {
779   SetCurrentScreen(GetScreen(ResetView::kScreenId));
780 }
781 
ShowKioskEnableScreen()782 void WizardController::ShowKioskEnableScreen() {
783   SetCurrentScreen(GetScreen(KioskEnableScreenView::kScreenId));
784 }
785 
ShowKioskAutolaunchScreen()786 void WizardController::ShowKioskAutolaunchScreen() {
787   SetCurrentScreen(GetScreen(KioskAutolaunchScreenView::kScreenId));
788 }
789 
ShowEnableAdbSideloadingScreen()790 void WizardController::ShowEnableAdbSideloadingScreen() {
791   SetCurrentScreen(GetScreen(EnableAdbSideloadingScreenView::kScreenId));
792 }
793 
ShowEnableDebuggingScreen()794 void WizardController::ShowEnableDebuggingScreen() {
795   SetCurrentScreen(GetScreen(EnableDebuggingScreenView::kScreenId));
796 }
797 
ShowTermsOfServiceScreen()798 void WizardController::ShowTermsOfServiceScreen() {
799   SetCurrentScreen(GetScreen(TermsOfServiceScreenView::kScreenId));
800 }
801 
ShowFamilyLinkNoticeScreen()802 void WizardController::ShowFamilyLinkNoticeScreen() {
803   AdvanceToScreen(FamilyLinkNoticeView::kScreenId);
804 }
805 
ShowSyncConsentScreen()806 void WizardController::ShowSyncConsentScreen() {
807   // First screen after login. Perform a timezone request so that any screens
808   // relying on geolocation can tailor their contents according to the user's
809   // region. Currently used on the MarketingOptInScreen.
810   StartNetworkTimezoneResolve();
811 
812   SetCurrentScreen(GetScreen(SyncConsentScreenView::kScreenId));
813 }
814 
ShowFingerprintSetupScreen()815 void WizardController::ShowFingerprintSetupScreen() {
816   SetCurrentScreen(GetScreen(FingerprintSetupScreenView::kScreenId));
817 }
818 
ShowMarketingOptInScreen()819 void WizardController::ShowMarketingOptInScreen() {
820   SetCurrentScreen(GetScreen(MarketingOptInScreenView::kScreenId));
821 }
822 
ShowArcTermsOfServiceScreen()823 void WizardController::ShowArcTermsOfServiceScreen() {
824   SetCurrentScreen(GetScreen(ArcTermsOfServiceScreenView::kScreenId));
825 }
826 
ShowRecommendAppsScreen()827 void WizardController::ShowRecommendAppsScreen() {
828   SetCurrentScreen(GetScreen(RecommendAppsScreenView::kScreenId));
829 }
830 
ShowAppDownloadingScreen()831 void WizardController::ShowAppDownloadingScreen() {
832   SetCurrentScreen(GetScreen(AppDownloadingScreenView::kScreenId));
833 }
834 
ShowWrongHWIDScreen()835 void WizardController::ShowWrongHWIDScreen() {
836   SetCurrentScreen(GetScreen(WrongHWIDScreenView::kScreenId));
837 }
838 
ShowAutoEnrollmentCheckScreen()839 void WizardController::ShowAutoEnrollmentCheckScreen() {
840   AutoEnrollmentCheckScreen* screen =
841       AutoEnrollmentCheckScreen::Get(screen_manager());
842   if (retry_auto_enrollment_check_)
843     screen->ClearState();
844   screen->set_auto_enrollment_controller(GetAutoEnrollmentController());
845   SetCurrentScreen(screen);
846 }
847 
ShowHIDDetectionScreen()848 void WizardController::ShowHIDDetectionScreen() {
849   SetCurrentScreen(GetScreen(HIDDetectionView::kScreenId));
850 }
851 
ShowDeviceDisabledScreen()852 void WizardController::ShowDeviceDisabledScreen() {
853   SetCurrentScreen(GetScreen(DeviceDisabledScreenView::kScreenId));
854 }
855 
ShowEncryptionMigrationScreen()856 void WizardController::ShowEncryptionMigrationScreen() {
857   SetCurrentScreen(GetScreen(EncryptionMigrationScreenView::kScreenId));
858 }
859 
ShowSupervisionTransitionScreen()860 void WizardController::ShowSupervisionTransitionScreen() {
861   SetCurrentScreen(GetScreen(SupervisionTransitionScreenView::kScreenId));
862 }
863 
ShowUpdateRequiredScreen()864 void WizardController::ShowUpdateRequiredScreen() {
865   SetCurrentScreen(GetScreen(UpdateRequiredView::kScreenId));
866 }
867 
ShowAssistantOptInFlowScreen()868 void WizardController::ShowAssistantOptInFlowScreen() {
869   SetCurrentScreen(GetScreen(AssistantOptInFlowScreenView::kScreenId));
870 }
871 
ShowMultiDeviceSetupScreen()872 void WizardController::ShowMultiDeviceSetupScreen() {
873   SetCurrentScreen(GetScreen(MultiDeviceSetupScreenView::kScreenId));
874 }
875 
ShowGestureNavigationScreen()876 void WizardController::ShowGestureNavigationScreen() {
877   SetCurrentScreen(GetScreen(GestureNavigationScreenView::kScreenId));
878 }
879 
ShowPinSetupScreen()880 void WizardController::ShowPinSetupScreen() {
881   SetCurrentScreen(GetScreen(PinSetupScreenView::kScreenId));
882 }
883 
ShowPackagedLicenseScreen()884 void WizardController::ShowPackagedLicenseScreen() {
885   SetCurrentScreen(GetScreen(PackagedLicenseView::kScreenId));
886 }
887 
ShowEduCoexistenceLoginScreen()888 void WizardController::ShowEduCoexistenceLoginScreen() {
889   SetCurrentScreen(GetScreen(EduCoexistenceLoginScreen::kScreenId));
890 }
891 
ShowParentalHandoffScreen()892 void WizardController::ShowParentalHandoffScreen() {
893   SetCurrentScreen(GetScreen(ParentalHandoffScreenView::kScreenId));
894 }
895 
ShowActiveDirectoryPasswordChangeScreen(const std::string & username)896 void WizardController::ShowActiveDirectoryPasswordChangeScreen(
897     const std::string& username) {
898   GetScreen<ActiveDirectoryPasswordChangeScreen>()->SetUsername(username);
899   AdvanceToScreen(ActiveDirectoryPasswordChangeView::kScreenId);
900 }
901 
OnActiveDirectoryPasswordChangeScreenExit()902 void WizardController::OnActiveDirectoryPasswordChangeScreenExit() {
903   OnScreenExit(ActiveDirectoryPasswordChangeView::kScreenId,
904                kDefaultExitReason);
905   ShowLoginScreen();
906 }
907 
OnUserCreationScreenExit(UserCreationScreen::Result result)908 void WizardController::OnUserCreationScreenExit(
909     UserCreationScreen::Result result) {
910   OnScreenExit(UserCreationView::kScreenId,
911                UserCreationScreen::GetResultString(result));
912   switch (result) {
913     case UserCreationScreen::Result::SIGNIN:
914     case UserCreationScreen::Result::SKIPPED:
915       if (g_browser_process->platform_part()
916               ->browser_policy_connector_chromeos()
917               ->GetDeviceMode() == policy::DEVICE_MODE_ENTERPRISE_AD) {
918         AdvanceToScreen(ActiveDirectoryLoginView::kScreenId);
919       } else {
920         GetScreen<GaiaScreen>()->LoadOnline(EmptyAccountId());
921         AdvanceToScreen(GaiaView::kScreenId);
922       }
923       break;
924     case UserCreationScreen::Result::CHILD_SIGNIN:
925       GetScreen<GaiaScreen>()->LoadOnlineForChildSignin();
926       AdvanceToScreen(GaiaView::kScreenId);
927       break;
928     case UserCreationScreen::Result::CHILD_ACCOUNT_CREATE:
929       GetScreen<GaiaScreen>()->LoadOnlineForChildSignup();
930       AdvanceToScreen(GaiaView::kScreenId);
931       break;
932     case UserCreationScreen::Result::ENTERPRISE_ENROLL:
933       AdvanceToScreen(EnrollmentScreenView::kScreenId);
934       break;
935     case UserCreationScreen::Result::CANCEL:
936       LoginDisplayHost::default_host()->HideOobeDialog();
937       break;
938   }
939 }
940 
OnGaiaScreenExit(GaiaScreen::Result result)941 void WizardController::OnGaiaScreenExit(GaiaScreen::Result result) {
942   OnScreenExit(GaiaView::kScreenId, GaiaScreen::GetResultString(result));
943   switch (result) {
944     case GaiaScreen::Result::BACK:
945       AdvanceToScreen(UserCreationView::kScreenId);
946       break;
947     case GaiaScreen::Result::CLOSE_DIALOG:
948       LoginDisplayHost::default_host()->HideOobeDialog();
949       break;
950   }
951 }
952 
OnActiveDirectoryLoginScreenExit()953 void WizardController::OnActiveDirectoryLoginScreenExit() {
954   OnScreenExit(ActiveDirectoryLoginView::kScreenId, kDefaultExitReason);
955   LoginDisplayHost::default_host()->HideOobeDialog();
956 }
957 
OnEduCoexistenceLoginScreenExit(EduCoexistenceLoginScreen::Result result)958 void WizardController::OnEduCoexistenceLoginScreenExit(
959     EduCoexistenceLoginScreen::Result result) {
960   OnScreenExit(EduCoexistenceLoginScreen::kScreenId,
961                EduCoexistenceLoginScreen::GetResultString(result));
962   ShowSyncConsentScreen();
963 }
964 
OnParentalHandoffScreenExit(ParentalHandoffScreen::Result result)965 void WizardController::OnParentalHandoffScreenExit(
966     ParentalHandoffScreen::Result result) {
967   OnScreenExit(ParentalHandoffScreenView::kScreenId,
968                ParentalHandoffScreen::GetResultString(result));
969   ShowMultiDeviceSetupScreen();
970 }
971 
SkipToLoginForTesting()972 void WizardController::SkipToLoginForTesting() {
973   VLOG(1) << "WizardController::SkipToLoginForTesting()";
974   if (current_screen_ && current_screen_->screen_id() == GaiaView::kScreenId)
975     return;
976   wizard_context_->skip_to_login_for_tests = true;
977   StartupUtils::MarkEulaAccepted();
978 
979   PerformPostEulaActions();
980   OnDeviceDisabledChecked(false /* device_disabled */);
981 }
982 
SkipToUpdateForTesting()983 void WizardController::SkipToUpdateForTesting() {
984   VLOG(1) << "SkipToUpdateForTesting.";
985   wizard_context_->skip_to_update_for_tests = true;
986   StartupUtils::MarkEulaAccepted();
987   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
988           chromeos::switches::kDisableHIDDetectionOnOOBEForTesting)) {
989     // We store the flag into local state so it persists restart after the
990     // update. Command line switch does not persist the restart during the
991     // test.
992     StartupUtils::DisableHIDDetectionScreenForTests();
993   }
994   PerformPostEulaActions();
995   InitiateOOBEUpdate();
996 }
997 
OnScreenExit(OobeScreenId screen,const std::string & exit_reason)998 void WizardController::OnScreenExit(OobeScreenId screen,
999                                     const std::string& exit_reason) {
1000   VLOG(1) << "Wizard screen " << screen
1001           << " exited with reason: " << exit_reason;
1002   // Do not perform checks and record stats for the skipped screen.
1003   if (exit_reason == chromeos::BaseScreen::kNotApplicable)
1004     return;
1005   DCHECK(current_screen_->screen_id() == screen);
1006 
1007   RecordUMAHistogramForOOBEStepCompletionTime(
1008       screen, exit_reason, base::TimeTicks::Now() - screen_show_times_[screen]);
1009 }
1010 
1011 ///////////////////////////////////////////////////////////////////////////////
1012 // WizardController, ExitHandlers:
OnWrongHWIDScreenExit()1013 void WizardController::OnWrongHWIDScreenExit() {
1014   OnScreenExit(WrongHWIDScreenView::kScreenId, kDefaultExitReason);
1015   OnDeviceModificationCanceled();
1016 }
1017 
OnHidDetectionScreenExit(HIDDetectionScreen::Result result)1018 void WizardController::OnHidDetectionScreenExit(
1019     HIDDetectionScreen::Result result) {
1020   OnScreenExit(HIDDetectionView::kScreenId,
1021                HIDDetectionScreen::GetResultString(result));
1022 
1023   if (result == HIDDetectionScreen::Result::START_DEMO) {
1024     LoginDisplayHost::default_host()->StartDemoAppLaunch();
1025     return;
1026   }
1027 
1028   AdvanceToScreenAfterHIDDetection(OobeScreen::SCREEN_UNKNOWN);
1029 }
1030 
OnWelcomeScreenExit(WelcomeScreen::Result result)1031 void WizardController::OnWelcomeScreenExit(WelcomeScreen::Result result) {
1032   OnScreenExit(WelcomeView::kScreenId, WelcomeScreen::GetResultString(result));
1033 
1034   switch (result) {
1035     case WelcomeScreen::Result::START_DEMO:
1036       LoginDisplayHost::default_host()->StartDemoAppLaunch();
1037       return;
1038     case WelcomeScreen::Result::SETUP_DEMO:
1039       StartDemoModeSetup();
1040       return;
1041     case WelcomeScreen::Result::ENABLE_DEBUGGING:
1042       ShowEnableDebuggingScreen();
1043       return;
1044     case WelcomeScreen::Result::NEXT:
1045       ShowNetworkScreen();
1046       return;
1047   }
1048 }
1049 
OnNetworkScreenExit(NetworkScreen::Result result)1050 void WizardController::OnNetworkScreenExit(NetworkScreen::Result result) {
1051   OnScreenExit(NetworkScreenView::kScreenId,
1052                NetworkScreen::GetResultString(result));
1053 
1054   if (result == NetworkScreen::Result::BACK) {
1055     if (demo_setup_controller_) {
1056       ShowDemoModePreferencesScreen();
1057     } else {
1058       ShowWelcomeScreen();
1059     }
1060     return;
1061   }
1062 
1063   // Update the demo setup config for demo setup flow.
1064   if (demo_setup_controller_) {
1065     switch (result) {
1066       case NetworkScreen::Result::CONNECTED:
1067         demo_setup_controller_->set_demo_config(
1068             DemoSession::DemoModeConfig::kOnline);
1069         break;
1070       case NetworkScreen::Result::OFFLINE_DEMO_SETUP:
1071         demo_setup_controller_->set_demo_config(
1072             DemoSession::DemoModeConfig::kOffline);
1073         break;
1074       case NetworkScreen::Result::BACK:
1075         NOTREACHED();
1076     }
1077   }
1078 
1079   if (ShowEulaOrArcTosAfterNetworkScreen())
1080     return;
1081 
1082   switch (result) {
1083     case NetworkScreen::Result::CONNECTED:
1084       InitiateOOBEUpdate();
1085       break;
1086     case NetworkScreen::Result::OFFLINE_DEMO_SETUP:
1087       // TODO(agawronska): Maybe check if device is connected to the network
1088       // and attempt system update. It is possible to initiate offline demo
1089       // setup on the device that is connected, although it is probably not
1090       // common.
1091       ShowDemoModeSetupScreen();
1092       break;
1093     case NetworkScreen::Result::BACK:
1094       NOTREACHED();
1095   }
1096 }
1097 
ShowEulaOrArcTosAfterNetworkScreen()1098 bool WizardController::ShowEulaOrArcTosAfterNetworkScreen() {
1099   if (!is_branded_build_)
1100     return false;
1101 
1102   if (!StartupUtils::IsEulaAccepted()) {
1103     ShowEulaScreen();
1104     return true;
1105   }
1106   if (arc::IsArcTermsOfServiceOobeNegotiationNeeded()) {
1107     ShowArcTermsOfServiceScreen();
1108     return true;
1109   }
1110 
1111   // This is reachable in case of a reboot during previous OOBE flow after EULA
1112   // was accepted and ARC terms of service handled - for example due to a forced
1113   // update (which is the next step, with the exception of offline demo mode
1114   // setup).
1115   return false;
1116 }
1117 
OnEulaScreenExit(EulaScreen::Result result)1118 void WizardController::OnEulaScreenExit(EulaScreen::Result result) {
1119   OnScreenExit(EulaView::kScreenId, EulaScreen::GetResultString(result));
1120 
1121   switch (result) {
1122     case EulaScreen::Result::ACCEPTED_WITH_USAGE_STATS_REPORTING:
1123       OnEulaAccepted(true /*usage_statistics_reporting_enabled*/);
1124       break;
1125     case EulaScreen::Result::ACCEPTED_WITHOUT_USAGE_STATS_REPORTING:
1126       OnEulaAccepted(false /*usage_statistics_reporting_enabled*/);
1127       break;
1128     case EulaScreen::Result::BACK:
1129       ShowNetworkScreen();
1130       break;
1131   }
1132 }
1133 
OnEulaAccepted(bool usage_statistics_reporting_enabled)1134 void WizardController::OnEulaAccepted(bool usage_statistics_reporting_enabled) {
1135   time_eula_accepted_ = base::TimeTicks::Now();
1136   StartupUtils::MarkEulaAccepted();
1137   ChangeMetricsReportingStateWithReply(
1138       usage_statistics_reporting_enabled,
1139       base::BindRepeating(&WizardController::OnChangedMetricsReportingState,
1140                           weak_factory_.GetWeakPtr()));
1141   PerformPostEulaActions();
1142 
1143   if (arc::IsArcTermsOfServiceOobeNegotiationNeeded()) {
1144     ShowArcTermsOfServiceScreen();
1145     return;
1146   } else if (demo_setup_controller_) {
1147     ShowDemoModeSetupScreen();
1148   }
1149 
1150   InitiateOOBEUpdate();
1151 }
1152 
OnUpdateScreenExit(UpdateScreen::Result result)1153 void WizardController::OnUpdateScreenExit(UpdateScreen::Result result) {
1154   OnScreenExit(UpdateView::kScreenId, UpdateScreen::GetResultString(result));
1155 
1156   switch (result) {
1157     case UpdateScreen::Result::UPDATE_NOT_REQUIRED:
1158     case UpdateScreen::Result::UPDATE_SKIPPED:
1159       OnUpdateCompleted();
1160       break;
1161     case UpdateScreen::Result::UPDATE_ERROR:
1162       // Ignore update errors if the OOBE flow has already completed - this
1163       // prevents the user getting blocked from getting to the login screen.
1164       if (is_out_of_box_) {
1165         ShowNetworkScreen();
1166       } else {
1167         OnUpdateCompleted();
1168       }
1169       break;
1170   }
1171 }
1172 
OnUpdateCompleted()1173 void WizardController::OnUpdateCompleted() {
1174   ShowAutoEnrollmentCheckScreen();
1175 }
1176 
OnAutoEnrollmentCheckScreenExit()1177 void WizardController::OnAutoEnrollmentCheckScreenExit() {
1178   OnScreenExit(AutoEnrollmentCheckScreenView::kScreenId, kDefaultExitReason);
1179   VLOG(1) << "WizardController::OnAutoEnrollmentCheckScreenExit()";
1180   // Check whether the device is disabled. OnDeviceDisabledChecked() will be
1181   // invoked when the result of this check is known. Until then, the current
1182   // screen will remain visible and will continue showing a spinner.
1183   g_browser_process->platform_part()
1184       ->device_disabling_manager()
1185       ->CheckWhetherDeviceDisabledDuringOOBE(
1186           base::BindRepeating(&WizardController::OnDeviceDisabledChecked,
1187                               weak_factory_.GetWeakPtr()));
1188 }
1189 
OnEnrollmentScreenExit(EnrollmentScreen::Result result)1190 void WizardController::OnEnrollmentScreenExit(EnrollmentScreen::Result result) {
1191   OnScreenExit(EnrollmentScreenView::kScreenId,
1192                EnrollmentScreen::GetResultString(result));
1193   VLOG(1) << "WizardController::OnEnrollmentScreenExit(result= "
1194           << EnrollmentScreen::GetResultString(result) << ").";
1195   switch (result) {
1196     case EnrollmentScreen::Result::COMPLETED:
1197     case EnrollmentScreen::Result::SKIPPED_FOR_TESTS:
1198       OnEnrollmentDone();
1199       break;
1200     case EnrollmentScreen::Result::BACK:
1201       retry_auto_enrollment_check_ = true;
1202       ShowAutoEnrollmentCheckScreen();
1203       break;
1204   }
1205 }
1206 
OnEnrollmentDone()1207 void WizardController::OnEnrollmentDone() {
1208   PerformOOBECompletedActions();
1209 
1210   // Fetch the rollback flag from `oobe_configuration_`.
1211   bool enrollment_mode_rollback = false;
1212   auto* restore_after_rollback_value =
1213       wizard_context_->configuration.FindKeyOfType(
1214           configuration::kRestoreAfterRollback, base::Value::Type::BOOLEAN);
1215   if (restore_after_rollback_value)
1216     enrollment_mode_rollback = restore_after_rollback_value->GetBool();
1217 
1218   // Restart to make the login page pick up the policy changes resulting from
1219   // enrollment recovery.  (Not pretty, but this codepath is rarely exercised.)
1220   if (prescribed_enrollment_config_.mode ==
1221           policy::EnrollmentConfig::MODE_RECOVERY ||
1222       enrollment_mode_rollback) {
1223     LOG(WARNING) << "Restart Chrome to pick up the policy changes";
1224     chrome::AttemptRestart();
1225     return;
1226   }
1227 
1228   // We need a log to understand when the device finished enrollment.
1229   VLOG(1) << "Enrollment done";
1230 
1231   if (KioskAppManager::Get()->IsAutoLaunchEnabled()) {
1232     AutoLaunchKioskApp(KioskAppType::CHROME_APP);
1233   } else if (WebKioskAppManager::Get()->GetAutoLaunchAccountId().is_valid()) {
1234     AutoLaunchKioskApp(KioskAppType::WEB_APP);
1235   } else if (ArcKioskAppManager::Get()->GetAutoLaunchAccountId().is_valid()) {
1236     AutoLaunchKioskApp(KioskAppType::ARC_APP);
1237   } else if (g_browser_process->platform_part()
1238                  ->browser_policy_connector_chromeos()
1239                  ->IsEnterpriseManaged()) {
1240     // Could be not managed in tests.
1241     DCHECK_EQ(LoginDisplayHost::default_host()->GetOobeUI()->display_type(),
1242               OobeUI::kOobeDisplay);
1243     SwitchWebUItoMojo();
1244   } else {
1245     ShowLoginScreen();
1246   }
1247 }
1248 
OnEnableAdbSideloadingScreenExit()1249 void WizardController::OnEnableAdbSideloadingScreenExit() {
1250   OnScreenExit(EnableAdbSideloadingScreenView::kScreenId, kDefaultExitReason);
1251 
1252   OnDeviceModificationCanceled();
1253 }
1254 
OnEnableDebuggingScreenExit()1255 void WizardController::OnEnableDebuggingScreenExit() {
1256   OnScreenExit(EnableDebuggingScreenView::kScreenId, kDefaultExitReason);
1257 
1258   OnDeviceModificationCanceled();
1259 }
1260 
OnKioskEnableScreenExit()1261 void WizardController::OnKioskEnableScreenExit() {
1262   OnScreenExit(KioskEnableScreenView::kScreenId, kDefaultExitReason);
1263 
1264   ShowLoginScreen();
1265 }
1266 
OnKioskAutolaunchScreenExit(KioskAutolaunchScreen::Result result)1267 void WizardController::OnKioskAutolaunchScreenExit(
1268     KioskAutolaunchScreen::Result result) {
1269   OnScreenExit(KioskAutolaunchScreenView::kScreenId,
1270                KioskAutolaunchScreen::GetResultString(result));
1271 
1272   switch (result) {
1273     case KioskAutolaunchScreen::Result::COMPLETED:
1274       DCHECK(KioskAppManager::Get()->IsAutoLaunchEnabled());
1275       AutoLaunchKioskApp(KioskAppType::CHROME_APP);
1276       break;
1277     case KioskAutolaunchScreen::Result::CANCELED:
1278       ShowLoginScreen();
1279       break;
1280   }
1281 }
1282 
OnDemoPreferencesScreenExit(DemoPreferencesScreen::Result result)1283 void WizardController::OnDemoPreferencesScreenExit(
1284     DemoPreferencesScreen::Result result) {
1285   OnScreenExit(DemoPreferencesScreenView::kScreenId,
1286                DemoPreferencesScreen::GetResultString(result));
1287 
1288   DCHECK(demo_setup_controller_);
1289 
1290   switch (result) {
1291     case DemoPreferencesScreen::Result::COMPLETED:
1292       ShowNetworkScreen();
1293       break;
1294     case DemoPreferencesScreen::Result::CANCELED:
1295       demo_setup_controller_.reset();
1296       ShowWelcomeScreen();
1297       break;
1298   }
1299 }
1300 
OnDemoSetupScreenExit(DemoSetupScreen::Result result)1301 void WizardController::OnDemoSetupScreenExit(DemoSetupScreen::Result result) {
1302   OnScreenExit(DemoSetupScreenView::kScreenId,
1303                DemoSetupScreen::GetResultString(result));
1304 
1305   DCHECK(demo_setup_controller_);
1306   demo_setup_controller_.reset();
1307 
1308   switch (result) {
1309     case DemoSetupScreen::Result::COMPLETED:
1310       PerformOOBECompletedActions();
1311       ShowLoginScreen();
1312       break;
1313     case DemoSetupScreen::Result::CANCELED:
1314       ShowWelcomeScreen();
1315       break;
1316   }
1317 }
1318 
OnTermsOfServiceScreenExit(TermsOfServiceScreen::Result result)1319 void WizardController::OnTermsOfServiceScreenExit(
1320     TermsOfServiceScreen::Result result) {
1321   OnScreenExit(TermsOfServiceScreenView::kScreenId,
1322                TermsOfServiceScreen::GetResultString(result));
1323 
1324   switch (result) {
1325     case TermsOfServiceScreen::Result::ACCEPTED:
1326     case TermsOfServiceScreen::Result::NOT_APPLICABLE:
1327       ShowFamilyLinkNoticeScreen();
1328       break;
1329     case TermsOfServiceScreen::Result::DECLINED:
1330       // End the session and return to the login screen.
1331       SessionManagerClient::Get()->StopSession(
1332           login_manager::SessionStopReason::TERMS_DECLINED);
1333       break;
1334   }
1335 }
1336 
OnFamilyLinkNoticeScreenExit(FamilyLinkNoticeScreen::Result result)1337 void WizardController::OnFamilyLinkNoticeScreenExit(
1338     FamilyLinkNoticeScreen::Result result) {
1339   OnScreenExit(FamilyLinkNoticeView::kScreenId,
1340                FamilyLinkNoticeScreen::GetResultString(result));
1341 
1342   ShowEduCoexistenceLoginScreen();
1343 }
1344 
OnSyncConsentScreenExit(SyncConsentScreen::Result result)1345 void WizardController::OnSyncConsentScreenExit(
1346     SyncConsentScreen::Result result) {
1347   OnScreenExit(SyncConsentScreenView::kScreenId,
1348                SyncConsentScreen::GetResultString(result));
1349   ShowFingerprintSetupScreen();
1350 }
1351 
OnFingerprintSetupScreenExit(FingerprintSetupScreen::Result result)1352 void WizardController::OnFingerprintSetupScreenExit(
1353     FingerprintSetupScreen::Result result) {
1354   OnScreenExit(FingerprintSetupScreenView::kScreenId,
1355                FingerprintSetupScreen::GetResultString(result));
1356 
1357   ShowPinSetupScreen();
1358 }
1359 
OnPinSetupScreenExit(PinSetupScreen::Result result)1360 void WizardController::OnPinSetupScreenExit(PinSetupScreen::Result result) {
1361   OnScreenExit(PinSetupScreenView::kScreenId,
1362                PinSetupScreen::GetResultString(result));
1363 
1364   ShowArcTermsOfServiceScreen();
1365 }
1366 
OnArcTermsOfServiceScreenExit(ArcTermsOfServiceScreen::Result result)1367 void WizardController::OnArcTermsOfServiceScreenExit(
1368     ArcTermsOfServiceScreen::Result result) {
1369   OnScreenExit(ArcTermsOfServiceScreenView::kScreenId,
1370                ArcTermsOfServiceScreen::GetResultString(result));
1371 
1372   switch (result) {
1373     case ArcTermsOfServiceScreen::Result::ACCEPTED:
1374       OnArcTermsOfServiceAccepted();
1375       break;
1376     case ArcTermsOfServiceScreen::Result::NOT_APPLICABLE:
1377       ShowAssistantOptInFlowScreen();
1378       break;
1379     case ArcTermsOfServiceScreen::Result::BACK:
1380       DCHECK(demo_setup_controller_);
1381       DCHECK(StartupUtils::IsEulaAccepted());
1382       ShowNetworkScreen();
1383       break;
1384   }
1385 }
1386 
OnArcTermsOfServiceAccepted()1387 void WizardController::OnArcTermsOfServiceAccepted() {
1388   if (demo_setup_controller_) {
1389     if (demo_setup_controller_->IsOfflineEnrollment()) {
1390       ShowDemoModeSetupScreen();
1391     } else {
1392       InitiateOOBEUpdate();
1393     }
1394     return;
1395   }
1396   ShowRecommendAppsScreen();
1397 }
1398 
OnRecommendAppsScreenExit(RecommendAppsScreen::Result result)1399 void WizardController::OnRecommendAppsScreenExit(
1400     RecommendAppsScreen::Result result) {
1401   OnScreenExit(RecommendAppsScreenView::kScreenId,
1402                RecommendAppsScreen::GetResultString(result));
1403 
1404   switch (result) {
1405     case RecommendAppsScreen::Result::SELECTED:
1406       ShowAppDownloadingScreen();
1407       break;
1408     case RecommendAppsScreen::Result::SKIPPED:
1409     case RecommendAppsScreen::Result::NOT_APPLICABLE:
1410     case RecommendAppsScreen::Result::LOAD_ERROR:
1411       ShowAssistantOptInFlowScreen();
1412       break;
1413   }
1414 }
1415 
OnAppDownloadingScreenExit()1416 void WizardController::OnAppDownloadingScreenExit() {
1417   OnScreenExit(AppDownloadingScreenView::kScreenId, kDefaultExitReason);
1418 
1419   ShowAssistantOptInFlowScreen();
1420 }
1421 
OnAssistantOptInFlowScreenExit(AssistantOptInFlowScreen::Result result)1422 void WizardController::OnAssistantOptInFlowScreenExit(
1423     AssistantOptInFlowScreen::Result result) {
1424   OnScreenExit(AssistantOptInFlowScreenView::kScreenId,
1425                AssistantOptInFlowScreen::GetResultString(result));
1426   ShowParentalHandoffScreen();
1427 }
1428 
OnMultiDeviceSetupScreenExit(MultiDeviceSetupScreen::Result result)1429 void WizardController::OnMultiDeviceSetupScreenExit(
1430     MultiDeviceSetupScreen::Result result) {
1431   OnScreenExit(MultiDeviceSetupScreenView::kScreenId,
1432                MultiDeviceSetupScreen::GetResultString(result));
1433 
1434   ShowGestureNavigationScreen();
1435 }
1436 
OnGestureNavigationScreenExit(GestureNavigationScreen::Result result)1437 void WizardController::OnGestureNavigationScreenExit(
1438     GestureNavigationScreen::Result result) {
1439   OnScreenExit(GestureNavigationScreenView::kScreenId,
1440                GestureNavigationScreen::GetResultString(result));
1441 
1442   ShowMarketingOptInScreen();
1443 }
1444 
OnMarketingOptInScreenExit(MarketingOptInScreen::Result result)1445 void WizardController::OnMarketingOptInScreenExit(
1446     MarketingOptInScreen::Result result) {
1447   OnScreenExit(MarketingOptInScreenView::kScreenId,
1448                MarketingOptInScreen::GetResultString(result));
1449 
1450   OnOobeFlowFinished();
1451 }
1452 
OnResetScreenExit()1453 void WizardController::OnResetScreenExit() {
1454   OnScreenExit(ResetView::kScreenId, kResetScreenExitReason);
1455   OnDeviceModificationCanceled();
1456 }
1457 
OnChangedMetricsReportingState(bool enabled)1458 void WizardController::OnChangedMetricsReportingState(bool enabled) {
1459   StatsReportingController::Get()->SetEnabled(
1460       ProfileManager::GetActiveUserProfile(), enabled);
1461 }
1462 
OnDeviceModificationCanceled()1463 void WizardController::OnDeviceModificationCanceled() {
1464   current_screen_->Hide();
1465   current_screen_ = nullptr;
1466   if (previous_screen_) {
1467     if (IsSigninScreen(previous_screen_->screen_id())) {
1468       ShowLoginScreen();
1469     } else {
1470       SetCurrentScreen(previous_screen_);
1471     }
1472     return;
1473   }
1474   ShowPackagedLicenseScreen();
1475 }
1476 
OnSupervisionTransitionScreenExit()1477 void WizardController::OnSupervisionTransitionScreenExit() {
1478   OnScreenExit(SupervisionTransitionScreenView::kScreenId, kDefaultExitReason);
1479 
1480   OnOobeFlowFinished();
1481 }
1482 
OnUpdateRequiredScreenExit()1483 void WizardController::OnUpdateRequiredScreenExit() {
1484   current_screen_->Hide();
1485   current_screen_ = nullptr;
1486   ShowLoginScreen();
1487 }
1488 
OnPackagedLicenseScreenExit(PackagedLicenseScreen::Result result)1489 void WizardController::OnPackagedLicenseScreenExit(
1490     PackagedLicenseScreen::Result result) {
1491   OnScreenExit(PackagedLicenseView::kScreenId,
1492                PackagedLicenseScreen::GetResultString(result));
1493   switch (result) {
1494     case PackagedLicenseScreen::Result::DONT_ENROLL:
1495     case PackagedLicenseScreen::Result::NOT_APPLICABLE:
1496       ShowLoginScreen();
1497       break;
1498     case PackagedLicenseScreen::Result::ENROLL:
1499       ShowEnrollmentScreen();
1500       break;
1501   }
1502 }
1503 
OnOobeFlowFinished()1504 void WizardController::OnOobeFlowFinished() {
1505   SetCurrentScreen(nullptr);
1506 
1507   // Launch browser and delete login host controller.
1508   content::GetUIThreadTaskRunner({})->PostTask(
1509       FROM_HERE, base::BindOnce(&UserSessionManager::DoBrowserLaunch,
1510                                 UserSessionManager::GetInstance()->AsWeakPtr(),
1511                                 ProfileManager::GetActiveUserProfile(),
1512                                 GetLoginDisplayHost()));
1513 }
1514 
OnDeviceDisabledChecked(bool device_disabled)1515 void WizardController::OnDeviceDisabledChecked(bool device_disabled) {
1516   prescribed_enrollment_config_ = g_browser_process->platform_part()
1517                                       ->browser_policy_connector_chromeos()
1518                                       ->GetPrescribedEnrollmentConfig();
1519 
1520   bool configuration_forced_enrollment = false;
1521   auto* start_enrollment_value = wizard_context_->configuration.FindKeyOfType(
1522       configuration::kWizardAutoEnroll, base::Value::Type::BOOLEAN);
1523   if (start_enrollment_value)
1524     configuration_forced_enrollment = start_enrollment_value->GetBool();
1525 
1526   // Fetch the rollback flag from `configuration`. It is not stored in the
1527   // `prescribed_enrollment_config_`. To restore after rollback the enrollment
1528   // screen needs to be started. (crbug.com/1093928)
1529   auto* restore_after_rollback_value =
1530       wizard_context_->configuration.FindKeyOfType(
1531           configuration::kRestoreAfterRollback, base::Value::Type::BOOLEAN);
1532   if (restore_after_rollback_value)
1533     configuration_forced_enrollment |= restore_after_rollback_value->GetBool();
1534 
1535   if (device_disabled) {
1536     demo_setup_controller_.reset();
1537     ShowDeviceDisabledScreen();
1538   } else if (demo_setup_controller_) {
1539     ShowDemoModeSetupScreen();
1540   } else if (wizard_context_->enrollment_triggered_early ||
1541              prescribed_enrollment_config_.should_enroll() ||
1542              configuration_forced_enrollment) {
1543     VLOG(1) << "StartEnrollment from OnDeviceDisabledChecked("
1544             << "device_disabled=" << device_disabled << ") "
1545             << "skip_update_enroll_after_eula_="
1546             << wizard_context_->enrollment_triggered_early
1547             << ", prescribed_enrollment_config_.should_enroll()="
1548             << prescribed_enrollment_config_.should_enroll()
1549             << ", configuration_forced_enrollment="
1550             << configuration_forced_enrollment;
1551     StartEnrollmentScreen(wizard_context_->enrollment_triggered_early);
1552   } else {
1553     PerformOOBECompletedActions();
1554     ShowPackagedLicenseScreen();
1555   }
1556 }
1557 
InitiateOOBEUpdate()1558 void WizardController::InitiateOOBEUpdate() {
1559   // If this is a Cellular First device, instruct UpdateEngine to allow
1560   // updates over cellular data connections.
1561   if (chromeos::switches::IsCellularFirstDevice()) {
1562     DBusThreadManager::Get()
1563         ->GetUpdateEngineClient()
1564         ->SetUpdateOverCellularPermission(
1565             true, base::BindOnce(&WizardController::StartOOBEUpdate,
1566                                  weak_factory_.GetWeakPtr()));
1567   } else {
1568     StartOOBEUpdate();
1569   }
1570 }
1571 
StartOOBEUpdate()1572 void WizardController::StartOOBEUpdate() {
1573   SetCurrentScreen(GetScreen(UpdateView::kScreenId));
1574 }
1575 
StartNetworkTimezoneResolve()1576 void WizardController::StartNetworkTimezoneResolve() {
1577   // Bypass the network requests for the geolocation and the timezone if the
1578   // timezone is being overridden through the command line.
1579   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
1580           switches::kOobeTimezoneOverrideForTests)) {
1581     auto timezone = std::make_unique<TimeZoneResponseData>();
1582     timezone->status = TimeZoneResponseData::OK;
1583     timezone->timeZoneId =
1584         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
1585             switches::kOobeTimezoneOverrideForTests);
1586     VLOG(1) << "Timezone is being overridden with : " << timezone->timeZoneId;
1587     OnTimezoneResolved(std::move(timezone), /*server_error*/ false);
1588     return;
1589   }
1590 
1591   DelayNetworkCall(
1592       base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS),
1593       base::Bind(&WizardController::StartTimezoneResolve,
1594                  weak_factory_.GetWeakPtr()));
1595 }
1596 
1597 // Resolving the timezone consists of first determining the location,
1598 // and then determining the timezone.
StartTimezoneResolve()1599 void WizardController::StartTimezoneResolve() {
1600   if (!g_browser_process->platform_part()
1601            ->GetTimezoneResolverManager()
1602            ->TimeZoneResolverShouldBeRunning()) {
1603     return;
1604   }
1605 
1606   auto& testing_factory = GetSharedURLLoaderFactoryForTesting();
1607   geolocation_provider_ = std::make_unique<SimpleGeolocationProvider>(
1608       testing_factory ? testing_factory
1609                       : g_browser_process->shared_url_loader_factory(),
1610       SimpleGeolocationProvider::DefaultGeolocationProviderURL());
1611   geolocation_provider_->RequestGeolocation(
1612       base::TimeDelta::FromSeconds(kResolveTimeZoneTimeoutSeconds),
1613       false /* send_wifi_geolocation_data */,
1614       false /* send_cellular_geolocation_data */,
1615       base::BindOnce(&WizardController::OnLocationResolved,
1616                      weak_factory_.GetWeakPtr()));
1617 }
1618 
PerformPostEulaActions()1619 void WizardController::PerformPostEulaActions() {
1620   StartNetworkTimezoneResolve();
1621   DelayNetworkCall(
1622       base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS),
1623       ServicesCustomizationDocument::GetInstance()
1624           ->EnsureCustomizationAppliedClosure());
1625 
1626   // Now that EULA has been accepted (for official builds), enable portal check.
1627   // ChromiumOS builds would go though this code path too.
1628   NetworkHandler::Get()->network_state_handler()->SetCheckPortalList(
1629       NetworkStateHandler::kDefaultCheckPortalList);
1630   GetAutoEnrollmentController()->Start();
1631   GetLoginDisplayHost()->PrewarmAuthentication();
1632   network_portal_detector::GetInstance()->Enable(true);
1633 }
1634 
PerformOOBECompletedActions()1635 void WizardController::PerformOOBECompletedActions() {
1636   // Avoid marking OOBE as completed multiple times if going from login screen
1637   // to enrollment screen (and back).
1638   if (oobe_marked_completed_) {
1639     return;
1640   }
1641 
1642   UMA_HISTOGRAM_COUNTS_100(
1643       "HIDDetection.TimesDialogShownPerOOBECompleted",
1644       GetLocalState()->GetInteger(prefs::kTimesHIDDialogShown));
1645   GetLocalState()->ClearPref(prefs::kTimesHIDDialogShown);
1646   StartupUtils::MarkOobeCompleted();
1647   oobe_marked_completed_ = true;
1648 }
1649 
SetCurrentScreen(BaseScreen * new_current)1650 void WizardController::SetCurrentScreen(BaseScreen* new_current) {
1651   VLOG(1) << "SetCurrentScreen: "
1652           << (new_current ? new_current->screen_id().name : "null");
1653   if (new_current && new_current->MaybeSkip(wizard_context_.get()))
1654     return;
1655 
1656   if (current_screen_ == new_current || GetOobeUI() == nullptr)
1657     return;
1658 
1659   if (current_screen_) {
1660     current_screen_->Hide();
1661   }
1662 
1663   previous_screen_ = current_screen_;
1664   current_screen_ = new_current;
1665 
1666   if (!current_screen_) {
1667     NotifyScreenChanged();
1668     return;
1669   }
1670 
1671   // Record show time for UMA.
1672   screen_show_times_[new_current->screen_id()] = base::TimeTicks::Now();
1673 
1674   // First remember how far have we reached so that we can resume if needed.
1675   if (is_out_of_box_ && !demo_setup_controller_ &&
1676       IsResumableScreen(current_screen_->screen_id())) {
1677     StartupUtils::SaveOobePendingScreen(current_screen_->screen_id().name);
1678   }
1679 
1680   UpdateStatusAreaVisibilityForScreen(current_screen_->screen_id());
1681   current_screen_->Show(wizard_context_.get());
1682   NotifyScreenChanged();
1683 }
1684 
UpdateStatusAreaVisibilityForScreen(OobeScreenId screen_id)1685 void WizardController::UpdateStatusAreaVisibilityForScreen(
1686     OobeScreenId screen_id) {
1687   if (screen_id == WelcomeView::kScreenId) {
1688     // Hide the status area initially; it only appears after OOBE first animates
1689     // in. Keep it visible if the user goes back to the existing welcome screen.
1690     GetLoginDisplayHost()->SetStatusAreaVisible(
1691         screen_manager_->HasScreen(WelcomeView::kScreenId));
1692   } else {
1693     GetLoginDisplayHost()->SetStatusAreaVisible(
1694         !ShouldHideStatusArea(screen_id));
1695   }
1696 }
1697 
OnHIDScreenNecessityCheck(bool screen_needed)1698 void WizardController::OnHIDScreenNecessityCheck(bool screen_needed) {
1699   if (!GetOobeUI())
1700     return;
1701 
1702   // Check for tests configuration.
1703   if (wizard_context_->skip_to_update_for_tests)
1704     return;
1705 
1706   if (screen_needed)
1707     ShowHIDDetectionScreen();
1708   else
1709     AdvanceToScreenAfterHIDDetection(OobeScreen::SCREEN_UNKNOWN);
1710 }
1711 
UpdateOobeConfiguration()1712 void WizardController::UpdateOobeConfiguration() {
1713   wizard_context_->configuration = base::Value(base::Value::Type::DICTIONARY);
1714   chromeos::configuration::FilterConfiguration(
1715       OobeConfiguration::Get()->GetConfiguration(),
1716       chromeos::configuration::ConfigurationHandlerSide::HANDLER_CPP,
1717       wizard_context_->configuration);
1718   auto* requisition_value = wizard_context_->configuration.FindKeyOfType(
1719       configuration::kDeviceRequisition, base::Value::Type::STRING);
1720   if (requisition_value) {
1721     VLOG(1) << "Using Device Requisition from configuration"
1722             << requisition_value->GetString();
1723     policy::EnrollmentRequisitionManager::SetDeviceRequisition(
1724         requisition_value->GetString());
1725   }
1726 }
1727 
CanNavigateTo(OobeScreenId screen_id)1728 bool WizardController::CanNavigateTo(OobeScreenId screen_id) {
1729   if (!current_screen_)
1730     return true;
1731   BaseScreen* next_screen = GetScreen(screen_id);
1732   return next_screen->screen_priority() <= current_screen_->screen_priority();
1733 }
1734 
AdvanceToScreen(OobeScreenId screen_id)1735 void WizardController::AdvanceToScreen(OobeScreenId screen_id) {
1736   if (!CanNavigateTo(screen_id)) {
1737     LOG(WARNING) << "Cannot advance to screen : " << screen_id
1738                  << " as it's priority is less than the current screen : "
1739                  << current_screen_->screen_id();
1740     return;
1741   }
1742   login_screen_started_ = false;
1743 
1744   if (screen_id == WelcomeView::kScreenId) {
1745     ShowWelcomeScreen();
1746   } else if (screen_id == NetworkScreenView::kScreenId) {
1747     ShowNetworkScreen();
1748   } else if (screen_id == PackagedLicenseView::kScreenId) {
1749     ShowPackagedLicenseScreen();
1750   } else if (screen_id == UpdateView::kScreenId) {
1751     InitiateOOBEUpdate();
1752   } else if (screen_id == EulaView::kScreenId) {
1753     ShowEulaScreen();
1754   } else if (screen_id == ResetView::kScreenId) {
1755     ShowResetScreen();
1756   } else if (screen_id == KioskEnableScreenView::kScreenId) {
1757     ShowKioskEnableScreen();
1758   } else if (screen_id == KioskAutolaunchScreenView::kScreenId) {
1759     ShowKioskAutolaunchScreen();
1760   } else if (screen_id == EnableAdbSideloadingScreenView::kScreenId) {
1761     ShowEnableAdbSideloadingScreen();
1762   } else if (screen_id == EnableDebuggingScreenView::kScreenId) {
1763     ShowEnableDebuggingScreen();
1764   } else if (screen_id == EnrollmentScreenView::kScreenId) {
1765     ShowEnrollmentScreen();
1766   } else if (screen_id == DemoSetupScreenView::kScreenId) {
1767     ShowDemoModeSetupScreen();
1768   } else if (screen_id == DemoPreferencesScreenView::kScreenId) {
1769     ShowDemoModePreferencesScreen();
1770   } else if (screen_id == TermsOfServiceScreenView::kScreenId) {
1771     ShowTermsOfServiceScreen();
1772   } else if (screen_id == SyncConsentScreenView::kScreenId) {
1773     ShowSyncConsentScreen();
1774   } else if (screen_id == ArcTermsOfServiceScreenView::kScreenId) {
1775     ShowArcTermsOfServiceScreen();
1776   } else if (screen_id == RecommendAppsScreenView::kScreenId) {
1777     ShowRecommendAppsScreen();
1778   } else if (screen_id == AppDownloadingScreenView::kScreenId) {
1779     ShowAppDownloadingScreen();
1780   } else if (screen_id == WrongHWIDScreenView::kScreenId) {
1781     ShowWrongHWIDScreen();
1782   } else if (screen_id == AutoEnrollmentCheckScreenView::kScreenId) {
1783     ShowAutoEnrollmentCheckScreen();
1784   } else if (screen_id == AppLaunchSplashScreenView::kScreenId) {
1785     AutoLaunchKioskApp(KioskAppType::CHROME_APP);
1786   } else if (screen_id == HIDDetectionView::kScreenId) {
1787     ShowHIDDetectionScreen();
1788   } else if (screen_id == DeviceDisabledScreenView::kScreenId) {
1789     ShowDeviceDisabledScreen();
1790   } else if (screen_id == EncryptionMigrationScreenView::kScreenId) {
1791     ShowEncryptionMigrationScreen();
1792   } else if (screen_id == UpdateRequiredView::kScreenId) {
1793     ShowUpdateRequiredScreen();
1794   } else if (screen_id == AssistantOptInFlowScreenView::kScreenId) {
1795     ShowAssistantOptInFlowScreen();
1796   } else if (screen_id == MultiDeviceSetupScreenView::kScreenId) {
1797     ShowMultiDeviceSetupScreen();
1798   } else if (screen_id == GestureNavigationScreenView::kScreenId) {
1799     ShowGestureNavigationScreen();
1800   } else if (screen_id == PinSetupScreenView::kScreenId) {
1801     ShowPinSetupScreen();
1802   } else if (screen_id == FingerprintSetupScreenView::kScreenId) {
1803     ShowFingerprintSetupScreen();
1804   } else if (screen_id == MarketingOptInScreenView::kScreenId) {
1805     ShowMarketingOptInScreen();
1806   } else if (screen_id == SupervisionTransitionScreenView::kScreenId) {
1807     ShowSupervisionTransitionScreen();
1808   } else if (screen_id == TpmErrorView::kScreenId ||
1809              screen_id == GaiaPasswordChangedView::kScreenId ||
1810              screen_id == ActiveDirectoryPasswordChangeView::kScreenId ||
1811              screen_id == FamilyLinkNoticeView::kScreenId ||
1812              screen_id == GaiaView::kScreenId ||
1813              screen_id == UserCreationView::kScreenId ||
1814              screen_id == ActiveDirectoryLoginView::kScreenId ||
1815              screen_id == SignInFatalErrorView::kScreenId) {
1816     SetCurrentScreen(GetScreen(screen_id));
1817   } else {
1818     NOTREACHED();
1819   }
1820 }
1821 
HandleAccelerator(ash::LoginAcceleratorAction action)1822 bool WizardController::HandleAccelerator(ash::LoginAcceleratorAction action) {
1823   if (current_screen_) {
1824     if (current_screen_->HandleAccelerator(action))
1825       return true;
1826   }
1827   return false;
1828 }
1829 
StartDemoModeSetup()1830 void WizardController::StartDemoModeSetup() {
1831   demo_setup_controller_ = std::make_unique<DemoSetupController>();
1832   ShowDemoModePreferencesScreen();
1833 }
1834 
SimulateDemoModeSetupForTesting(base::Optional<DemoSession::DemoModeConfig> demo_config)1835 void WizardController::SimulateDemoModeSetupForTesting(
1836     base::Optional<DemoSession::DemoModeConfig> demo_config) {
1837   if (!demo_setup_controller_)
1838     demo_setup_controller_ = std::make_unique<DemoSetupController>();
1839   if (demo_config.has_value())
1840     demo_setup_controller_->set_demo_config(*demo_config);
1841 }
1842 
ShowErrorScreen()1843 void WizardController::ShowErrorScreen() {
1844   SetCurrentScreen(GetScreen(ErrorScreenView::kScreenId));
1845 }
1846 
OnAccessibilityStatusChanged(const AccessibilityStatusEventDetails & details)1847 void WizardController::OnAccessibilityStatusChanged(
1848     const AccessibilityStatusEventDetails& details) {
1849   enum AccessibilityNotificationType type = details.notification_type;
1850   if (type == ACCESSIBILITY_MANAGER_SHUTDOWN) {
1851     accessibility_subscription_.reset();
1852     return;
1853   } else if (type != ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK || !details.enabled) {
1854     return;
1855   }
1856 
1857   CrasAudioHandler* cras = CrasAudioHandler::Get();
1858   if (cras->IsOutputMuted()) {
1859     cras->SetOutputMute(false);
1860     cras->SetOutputVolumePercent(kMinAudibleOutputVolumePercent);
1861   } else if (cras->GetOutputVolumePercent() < kMinAudibleOutputVolumePercent) {
1862     cras->SetOutputVolumePercent(kMinAudibleOutputVolumePercent);
1863   }
1864 }
1865 
AutoLaunchKioskApp(KioskAppType app_type)1866 void WizardController::AutoLaunchKioskApp(KioskAppType app_type) {
1867   KioskAppId kiosk_app_id;
1868   switch (app_type) {
1869     case KioskAppType::CHROME_APP: {
1870       KioskAppManagerBase::App app_data;
1871       std::string app_id = KioskAppManager::Get()->GetAutoLaunchApp();
1872       CHECK(KioskAppManager::Get()->GetApp(app_id, &app_data));
1873       kiosk_app_id = KioskAppId::ForChromeApp(app_id);
1874       break;
1875     }
1876     case KioskAppType::WEB_APP: {
1877       const AccountId account_id =
1878           WebKioskAppManager::Get()->GetAutoLaunchAccountId();
1879       kiosk_app_id = KioskAppId::ForWebApp(account_id);
1880       break;
1881     }
1882     case KioskAppType::ARC_APP:
1883       const AccountId account_id =
1884           ArcKioskAppManager::Get()->GetAutoLaunchAccountId();
1885       kiosk_app_id = KioskAppId::ForArcApp(account_id);
1886       break;
1887   }
1888 
1889   // Wait for the `CrosSettings` to become either trusted or permanently
1890   // untrusted.
1891   const CrosSettingsProvider::TrustedStatus status =
1892       CrosSettings::Get()->PrepareTrustedValues(
1893           base::BindOnce(&WizardController::AutoLaunchKioskApp,
1894                          weak_factory_.GetWeakPtr(), app_type));
1895   if (status == CrosSettingsProvider::TEMPORARILY_UNTRUSTED)
1896     return;
1897 
1898   if (status == CrosSettingsProvider::PERMANENTLY_UNTRUSTED) {
1899     // If the `cros_settings_` are permanently untrusted, show an error message
1900     // and refuse to auto-launch the kiosk app.
1901     GetErrorScreen()->SetUIState(NetworkError::UI_STATE_LOCAL_STATE_ERROR);
1902     GetLoginDisplayHost()->SetStatusAreaVisible(false);
1903     ShowErrorScreen();
1904     return;
1905   }
1906 
1907   if (system::DeviceDisablingManager::IsDeviceDisabledDuringNormalOperation()) {
1908     // If the device is disabled, bail out. A device disabled screen will be
1909     // shown by the DeviceDisablingManager.
1910     return;
1911   }
1912 
1913   constexpr bool auto_launch = true;
1914   GetLoginDisplayHost()->StartKiosk(kiosk_app_id, auto_launch);
1915 }
1916 
1917 // static
SetZeroDelays()1918 void WizardController::SetZeroDelays() {
1919   g_using_zero_delays = true;
1920 }
1921 
1922 // static
IsZeroDelayEnabled()1923 bool WizardController::IsZeroDelayEnabled() {
1924   return g_using_zero_delays;
1925 }
1926 
1927 // static
SkipPostLoginScreensForTesting()1928 void WizardController::SkipPostLoginScreensForTesting() {
1929   skip_post_login_screens_ = true;
1930   if (!default_controller() || !default_controller()->current_screen())
1931     return;
1932 
1933   const OobeScreenId current_screen_id =
1934       default_controller()->current_screen()->screen_id();
1935   if (current_screen_id == TermsOfServiceScreenView::kScreenId ||
1936       current_screen_id == FamilyLinkNoticeView::kScreenId ||
1937       current_screen_id == EduCoexistenceLoginScreen::kScreenId ||
1938       current_screen_id == SyncConsentScreenView::kScreenId ||
1939       current_screen_id == FingerprintSetupScreenView::kScreenId ||
1940       current_screen_id == ArcTermsOfServiceScreenView::kScreenId ||
1941       current_screen_id == PinSetupScreenView::kScreenId ||
1942       current_screen_id == MarketingOptInScreenView::kScreenId ||
1943       current_screen_id == ParentalHandoffScreenView::kScreenId) {
1944     default_controller()->OnOobeFlowFinished();
1945   } else {
1946     LOG(WARNING) << "SkipPostLoginScreensForTesting(): Ignore screen "
1947                  << current_screen_id.name;
1948   }
1949 }
1950 
1951 // static
SkipEnrollmentPromptsForTesting()1952 void WizardController::SkipEnrollmentPromptsForTesting() {
1953   skip_enrollment_prompts_ = true;
1954 }
1955 
1956 // static
1957 std::unique_ptr<base::AutoReset<bool>>
ForceBrandedBuildForTesting()1958 WizardController::ForceBrandedBuildForTesting() {
1959   return std::make_unique<base::AutoReset<bool>>(&is_branded_build_, true);
1960 }
1961 
1962 // static
UsingHandsOffEnrollment()1963 bool WizardController::UsingHandsOffEnrollment() {
1964   return policy::DeviceCloudPolicyManagerChromeOS::
1965              GetZeroTouchEnrollmentMode() ==
1966          policy::ZeroTouchEnrollmentMode::HANDS_OFF;
1967 }
1968 
1969 // static
IsSigninScreen(OobeScreenId screen_id)1970 bool WizardController::IsSigninScreen(OobeScreenId screen_id) {
1971   return screen_id == UserCreationView::kScreenId ||
1972          screen_id == GaiaView::kScreenId ||
1973          screen_id == SignInFatalErrorView::kScreenId;
1974 }
1975 
AddObserver(ScreenObserver * obs)1976 void WizardController::AddObserver(ScreenObserver* obs) {
1977   screen_observers_.AddObserver(obs);
1978 }
1979 
RemoveObserver(ScreenObserver * obs)1980 void WizardController::RemoveObserver(ScreenObserver* obs) {
1981   screen_observers_.RemoveObserver(obs);
1982 }
1983 
OnLocalStateInitialized(bool)1984 void WizardController::OnLocalStateInitialized(bool /* succeeded */) {
1985   if (GetLocalState()->GetInitializationStatus() !=
1986       PrefService::INITIALIZATION_STATUS_ERROR) {
1987     return;
1988   }
1989   GetErrorScreen()->SetUIState(NetworkError::UI_STATE_LOCAL_STATE_ERROR);
1990   GetLoginDisplayHost()->SetStatusAreaVisible(false);
1991   ShowErrorScreen();
1992 }
1993 
PrepareFirstRunPrefs()1994 void WizardController::PrepareFirstRunPrefs() {
1995   // Showoff starts in parallel to OOBE onboarding. We need to store the prefs
1996   // early to make sure showoff has the correct data when launched.
1997   Profile* profile = ProfileManager::GetActiveUserProfile();
1998   bool shouldShowParentalControl =
1999       wizard_context_->sign_in_as_child && !profile->IsChild() &&
2000       !profile->GetProfilePolicyConnector()->IsManaged();
2001   profile->GetPrefs()->SetBoolean(prefs::kHelpAppShouldShowParentalControl,
2002                                   shouldShowParentalControl);
2003 }
2004 
GetLocalState()2005 PrefService* WizardController::GetLocalState() {
2006   if (local_state_for_testing_)
2007     return local_state_for_testing_;
2008   return g_browser_process->local_state();
2009 }
2010 
OnTimezoneResolved(std::unique_ptr<TimeZoneResponseData> timezone,bool server_error)2011 void WizardController::OnTimezoneResolved(
2012     std::unique_ptr<TimeZoneResponseData> timezone,
2013     bool server_error) {
2014   DCHECK_CURRENTLY_ON(BrowserThread::UI);
2015   DCHECK(timezone);
2016 
2017   timezone_resolved_ = true;
2018   base::ScopedClosureRunner inform_test(on_timezone_resolved_for_testing_);
2019   on_timezone_resolved_for_testing_.Reset();
2020 
2021   VLOG(1) << "Resolved local timezone={" << timezone->ToStringForDebug()
2022           << "}.";
2023 
2024   if (timezone->status != TimeZoneResponseData::OK) {
2025     LOG(WARNING) << "Resolve TimeZone: failed to resolve timezone.";
2026     return;
2027   }
2028 
2029   policy::BrowserPolicyConnectorChromeOS* connector =
2030       g_browser_process->platform_part()->browser_policy_connector_chromeos();
2031   if (connector->IsEnterpriseManaged()) {
2032     std::string policy_timezone;
2033     if (CrosSettings::Get()->GetString(kSystemTimezonePolicy,
2034                                        &policy_timezone) &&
2035         !policy_timezone.empty()) {
2036       VLOG(1) << "Resolve TimeZone: TimeZone settings are overridden"
2037               << " by DevicePolicy.";
2038       return;
2039     }
2040   }
2041 
2042   if (!timezone->timeZoneId.empty()) {
2043     VLOG(1) << "Resolve TimeZone: setting timezone to '" << timezone->timeZoneId
2044             << "'";
2045     chromeos::system::SetSystemAndSigninScreenTimezone(timezone->timeZoneId);
2046   }
2047 }
2048 
GetTimezoneProvider()2049 TimeZoneProvider* WizardController::GetTimezoneProvider() {
2050   if (!timezone_provider_) {
2051     auto& testing_factory = GetSharedURLLoaderFactoryForTesting();
2052     timezone_provider_ = std::make_unique<TimeZoneProvider>(
2053         testing_factory ? testing_factory
2054                         : g_browser_process->shared_url_loader_factory(),
2055         DefaultTimezoneProviderURL());
2056   }
2057   return timezone_provider_.get();
2058 }
2059 
OnLocationResolved(const Geoposition & position,bool server_error,const base::TimeDelta elapsed)2060 void WizardController::OnLocationResolved(const Geoposition& position,
2061                                           bool server_error,
2062                                           const base::TimeDelta elapsed) {
2063   DCHECK_CURRENTLY_ON(BrowserThread::UI);
2064 
2065   const base::TimeDelta timeout =
2066       base::TimeDelta::FromSeconds(kResolveTimeZoneTimeoutSeconds);
2067   // Ignore invalid position.
2068   if (!position.Valid())
2069     return;
2070 
2071   if (elapsed >= timeout) {
2072     LOG(WARNING) << "Resolve TimeZone: got location after timeout ("
2073                  << elapsed.InSecondsF() << " seconds elapsed). Ignored.";
2074     return;
2075   }
2076 
2077   if (!g_browser_process->platform_part()
2078            ->GetTimezoneResolverManager()
2079            ->TimeZoneResolverShouldBeRunning()) {
2080     return;
2081   }
2082 
2083   // WizardController owns TimezoneProvider, so timezone request is silently
2084   // cancelled on destruction.
2085   GetTimezoneProvider()->RequestTimezone(
2086       position, timeout - elapsed,
2087       base::BindOnce(&WizardController::OnTimezoneResolved,
2088                      weak_factory_.GetWeakPtr()));
2089 }
2090 
SetOnTimeZoneResolvedForTesting(const base::Closure & callback)2091 bool WizardController::SetOnTimeZoneResolvedForTesting(
2092     const base::Closure& callback) {
2093   if (timezone_resolved_)
2094     return false;
2095 
2096   on_timezone_resolved_for_testing_ = callback;
2097   return true;
2098 }
2099 
StartEnrollmentScreen(bool force_interactive)2100 void WizardController::StartEnrollmentScreen(bool force_interactive) {
2101   VLOG(1) << "Showing enrollment screen."
2102           << " Forcing interactive enrollment: " << force_interactive << ".";
2103 
2104   // Determine the effective enrollment configuration. If there is a valid
2105   // prescribed configuration, use that. If not, figure out which variant of
2106   // manual enrollment is taking place.
2107   // If OOBE Configuration exits, it might also affect enrollment configuration.
2108   policy::EnrollmentConfig effective_config = prescribed_enrollment_config_;
2109   if (!effective_config.should_enroll() ||
2110       (force_interactive && !effective_config.should_enroll_interactively())) {
2111     effective_config.mode =
2112         prescribed_enrollment_config_.management_domain.empty()
2113             ? policy::EnrollmentConfig::MODE_MANUAL
2114             : policy::EnrollmentConfig::MODE_MANUAL_REENROLLMENT;
2115   }
2116 
2117   // If chrome version is rolled back via policy, the device is actually
2118   // enrolled but some enrollment-flow steps still need to be taken.
2119   auto* restore_after_rollback_value =
2120       wizard_context_->configuration.FindKeyOfType(
2121           configuration::kRestoreAfterRollback, base::Value::Type::BOOLEAN);
2122   if (restore_after_rollback_value && restore_after_rollback_value->GetBool())
2123     effective_config.mode = policy::EnrollmentConfig::MODE_ENROLLED_ROLLBACK;
2124 
2125   // If enrollment token is specified via OOBE configuration use corresponding
2126   // configuration.
2127   auto* enrollment_token = wizard_context_->configuration.FindKeyOfType(
2128       configuration::kEnrollmentToken, base::Value::Type::STRING);
2129   if (enrollment_token && !enrollment_token->GetString().empty()) {
2130     effective_config.mode =
2131         policy::EnrollmentConfig::MODE_ATTESTATION_ENROLLMENT_TOKEN;
2132     effective_config.auth_mechanism =
2133         policy::EnrollmentConfig::AUTH_MECHANISM_ATTESTATION;
2134     effective_config.enrollment_token = enrollment_token->GetString();
2135   }
2136 
2137   EnrollmentScreen* screen = EnrollmentScreen::Get(screen_manager());
2138   screen->SetEnrollmentConfig(effective_config);
2139   UpdateStatusAreaVisibilityForScreen(EnrollmentScreenView::kScreenId);
2140   SetCurrentScreen(screen);
2141 }
2142 
NotifyScreenChanged()2143 void WizardController::NotifyScreenChanged() {
2144   for (ScreenObserver& obs : screen_observers_)
2145     obs.OnCurrentScreenChanged(current_screen_);
2146 }
2147 
GetAutoEnrollmentController()2148 AutoEnrollmentController* WizardController::GetAutoEnrollmentController() {
2149   if (!auto_enrollment_controller_)
2150     auto_enrollment_controller_ = std::make_unique<AutoEnrollmentController>();
2151   return auto_enrollment_controller_.get();
2152 }
2153 
2154 }  // namespace chromeos
2155