Enable bootstrapping feature by default.

chrome/browser/chromeos/login/wizard_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 
 #include <signal.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ skipping 124 matching lines @@
   histogram->AddTime(step_time);
 }
 
 bool IsRemoraRequisition() {
   return g_browser_process->platform_part()
       ->browser_policy_connector_chromeos()
       ->GetDeviceCloudPolicyManager()
       ->IsRemoraRequisition();
 }
 
-// Checks if the device is a "Slave" device in the bootstrapping process.
-bool IsBootstrappingSlave() {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      chromeos::switches::kOobeBootstrappingSlave);
+// Checks if a controller device ("Master") is detected during the bootstrapping
+// or shark/remora setup process.
+bool IsControllerDetected() {
+  return g_browser_process->local_state()->GetBoolean(
+      prefs::kOobeControllerDetected);
+}
+
+void SetControllerDetectedPref(bool value) {
+  PrefService* prefs = g_browser_process->local_state();
+  prefs->SetBoolean(prefs::kOobeControllerDetected, value);
+  prefs->CommitPendingWrite();
 }
 
 // Checks if the device is a "Master" device in the bootstrapping process.
 bool IsBootstrappingMaster() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kOobeBootstrappingMaster);
 }
 
 bool NetworkAllowUpdate(const chromeos::NetworkState* network) {
   if (!network || !network->IsConnectedState())
@@ skipping 72 matching lines @@
   DCHECK(default_controller_ == nullptr);
   default_controller_ = this;
   AccessibilityManager* accessibility_manager = AccessibilityManager::Get();
   CHECK(accessibility_manager);
   accessibility_subscription_ = accessibility_manager->RegisterCallback(
       base::Bind(&WizardController::OnAccessibilityStatusChanged,
                  base::Unretained(this)));
 }
 
 WizardController::~WizardController() {
+  if (shark_connection_listener_.get()) {
+    base::MessageLoop::current()->DeleteSoon(
+        FROM_HERE, shark_connection_listener_.release());
+  }
   if (default_controller_ == this) {
     default_controller_ = nullptr;
   } else {
     NOTREACHED() << "More than one controller are alive.";
   }
 }
 
 void WizardController::Init(const std::string& first_screen_name) {
   VLOG(1) << "Starting OOBE wizard with screen: " << first_screen_name;
   first_screen_name_ = first_screen_name;
@@ skipping 27 matching lines @@
 
   // If the device is a Master device in bootstrapping process (mostly for demo
   // and test purpose), start the enrollment OOBE flow.
   if (IsBootstrappingMaster())
     connector->GetDeviceCloudPolicyManager()->SetDeviceEnrollmentAutoStart();
 
   // Use the saved screen preference from Local State.
   const std::string screen_pref =
       GetLocalState()->GetString(prefs::kOobeScreenPending);
   if (is_out_of_box_ && !screen_pref.empty() && !IsRemoraPairingOobe() &&
-      !IsBootstrappingSlave() &&
+      !IsControllerDetected() &&
       (first_screen_name.empty() ||
        first_screen_name == WizardController::kTestNoScreenName)) {
     first_screen_name_ = screen_pref;
   }
+  // We need to reset the kOobeControllerDetected pref to allow the user to have
+  // the choice to setup the device manually. The pref will be set properly if
+  // an eligible controller is detected later.
+  SetControllerDetectedPref(false);
 
   AdvanceToScreen(first_screen_name_);
   if (!IsMachineHWIDCorrect() && !StartupUtils::IsDeviceRegistered() &&
       first_screen_name_.empty())
     ShowWrongHWIDScreen();
 }
 
 ErrorScreen* WizardController::GetErrorScreen() {
   return oobe_ui_->GetErrorScreen();
 }
@@ skipping 283 matching lines @@
   ShowLoginScreen(LoginScreenContext());
 }
 
 void WizardController::OnUpdateCompleted() {
   const bool is_shark = g_browser_process->platform_part()
                             ->browser_policy_connector_chromeos()
                             ->GetDeviceCloudPolicyManager()
                             ->IsSharkRequisition();
   if (is_shark || IsBootstrappingMaster()) {
     ShowControllerPairingScreen();
-  } else if (IsBootstrappingSlave() && shark_controller_detected_) {
+  } else if (IsControllerDetected()) {
     ShowHostPairingScreen();
   } else {
     ShowAutoEnrollmentCheckScreen();
   }
 }
 
 void WizardController::OnEulaAccepted() {
   time_eula_accepted_ = base::Time::Now();
   StartupUtils::MarkEulaAccepted();
   InitiateMetricsReportingChange(
@@ skipping 318 matching lines @@
     ShowHIDDetectionScreen();
   } else if (screen_name == kControllerPairingScreenName) {
     ShowControllerPairingScreen();
   } else if (screen_name == kHostPairingScreenName) {
     ShowHostPairingScreen();
   } else if (screen_name == kDeviceDisabledScreenName) {
     ShowDeviceDisabledScreen();
   } else if (screen_name != kTestNoScreenName) {
     if (is_out_of_box_) {
       time_oobe_started_ = base::Time::Now();
-      if (IsRemoraPairingOobe() || IsSlavePairingOobe()) {
+      if (IsRemoraPairingOobe() || IsControllerDetected()) {
         ShowHostPairingScreen();
       } else if (CanShowHIDDetectionScreen()) {
         hid_screen_ = GetScreen(kHIDDetectionScreenName);
         base::Callback<void(bool)> on_check = base::Bind(
             &WizardController::OnHIDScreenNecessityCheck,
             weak_factory_.GetWeakPtr());
         oobe_ui_->GetHIDDetectionView()->CheckIsScreenRequired(on_check);
       } else {
         ShowNetworkScreen();
       }
@@ skipping 356 matching lines @@
 bool WizardController::SetOnTimeZoneResolvedForTesting(
     const base::Closure& callback) {
   if (timezone_resolved_)
     return false;
 
   on_timezone_resolved_for_testing_ = callback;
   return true;
 }
 
 bool WizardController::IsRemoraPairingOobe() const {
-  return IsRemoraRequisition() &&
-         (base::CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kHostPairingOobe) ||
-          shark_controller_detected_);
-}
-
-bool WizardController::IsSlavePairingOobe() const {
-  return IsBootstrappingSlave() && shark_controller_detected_;
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kHostPairingOobe);
 }
 
 void WizardController::MaybeStartListeningForSharkConnection() {
-  if (!IsRemoraRequisition() && !IsBootstrappingSlave())
+  // We shouldn't be here if we are running pairing OOBE already.
+  if (IsControllerDetected())
     return;
 
-  // We shouldn't be here if we are running pairing OOBE already.
-  DCHECK(!IsRemoraPairingOobe() && !IsSlavePairingOobe());
-
   if (!shark_connection_listener_) {
     shark_connection_listener_.reset(
         new pairing_chromeos::SharkConnectionListener(
             base::Bind(&WizardController::OnSharkConnected,
                        weak_factory_.GetWeakPtr())));
   }
 }
 
 void WizardController::OnSharkConnected(
     scoped_ptr<pairing_chromeos::HostPairingController> remora_controller) {
   VLOG(1) << "OnSharkConnected";
   remora_controller_ = std::move(remora_controller);
   base::MessageLoop::current()->DeleteSoon(
       FROM_HERE, shark_connection_listener_.release());
-  shark_controller_detected_ = true;
+  SetControllerDetectedPref(true);
   ShowHostPairingScreen();
 }
 
 void WizardController::OnSetHostNetworkFailed() {
   remora_controller_->OnNetworkConnectivityChanged(
       pairing_chromeos::HostPairingController::CONNECTIVITY_NONE);
 }
 
 void WizardController::StartEnrollmentScreen() {
   VLOG(1) << "Showing enrollment screen.";
 
   // Determine the effective enrollment configuration. If there is a valid
   // prescribed configuration, use that. If not, figure out which variant of
   // manual enrollment is taking place.
   policy::EnrollmentConfig effective_config = prescribed_enrollment_config_;
   if (!effective_config.should_enroll()) {
     effective_config.mode =
         prescribed_enrollment_config_.management_domain.empty()
             ? policy::EnrollmentConfig::MODE_MANUAL
             : policy::EnrollmentConfig::MODE_MANUAL_REENROLLMENT;
   }
 
   EnrollmentScreen* screen = EnrollmentScreen::Get(this);
   screen->SetParameters(effective_config, shark_controller_.get());
   SetStatusAreaVisible(true);
   SetCurrentScreen(screen);
 }
 
 }  // namespace chromeos