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