Don't start FRE from the login screen

chrome/browser/chromeos/policy/auto_enrollment_client.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/policy/auto_enrollment_client.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/guid.h"
@@ skipping 61 matching lines @@
       return std::string();
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_REQUESTED:
       return kDeviceStateRestoreModeReEnrollmentRequested;
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED:
       return kDeviceStateRestoreModeReEnrollmentEnforced;
     case em::DeviceStateRetrievalResponse::RESTORE_MODE_DISABLED:
       return kDeviceStateRestoreModeDisabled;
   }
 
   // Return is required to avoid compiler warning.
-  NOTREACHED() << "Bad restore mode " << restore_mode;
+  NOTREACHED() << "Bad restore_mode=" << restore_mode;
   return std::string();
 }
 
 }  // namespace
 
 AutoEnrollmentClient::AutoEnrollmentClient(
     const ProgressCallback& callback,
     DeviceManagementService* service,
     PrefService* local_state,
     scoped_refptr<net::URLRequestContextGetter> system_request_context,
@@ skipping 91 matching lines @@
   has_server_state_ = has_server_state;
   return true;
 }
 
 bool AutoEnrollmentClient::RetryStep() {
   // If there is a pending request job, let it finish.
   if (request_job_)
     return true;
 
   if (GetCachedDecision()) {
+    VLOG(1) << "Cached: has_state=" << has_server_state_;
     // The bucket download check has completed already. If it came back
     // positive, then device state should be (re-)downloaded.
     if (has_server_state_) {
       if (!device_state_available_) {
         SendDeviceStateRequest();
         return true;
       }
     }
   } else {
     // Start bucket download.
@@ skipping 12 matching lines @@
     progress_callback_.Run(state_);
   }
 }
 
 void AutoEnrollmentClient::NextStep() {
   if (RetryStep())
     return;
 
   // Protocol finished successfully, report result.
   const RestoreMode restore_mode = GetRestoreMode();
-  if (restore_mode == RESTORE_MODE_REENROLLMENT_REQUESTED ||
-      restore_mode == RESTORE_MODE_REENROLLMENT_ENFORCED) {
-    ReportProgress(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT);
-  } else {
-    ReportProgress(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT);
+  switch (restore_mode) {
+    case RESTORE_MODE_NONE:
+    case RESTORE_MODE_DISABLED:
+      ReportProgress(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT);
+      break;
+    case RESTORE_MODE_REENROLLMENT_REQUESTED:
+    case RESTORE_MODE_REENROLLMENT_ENFORCED:
+      ReportProgress(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT);
+      break;
   }
 }
 
 void AutoEnrollmentClient::SendBucketDownloadRequest() {
   // Only power-of-2 moduli are supported for now. These are computed by taking
   // the lower |current_power_| bits of the hash.
   uint64_t remainder = 0;
   for (int i = 0; 8 * i < current_power_; ++i) {
     uint64_t byte = server_backed_state_key_hash_[31 - i] & 0xff;
     remainder = remainder | (byte << (8 * i));
   }
   remainder = remainder & ((UINT64_C(1) << current_power_) - 1);
 
   ReportProgress(AUTO_ENROLLMENT_STATE_PENDING);
 
+  VLOG(1) << "Request bucket #" << remainder;
   request_job_.reset(
       device_management_service_->CreateJob(
           DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT,
           request_context_.get()));
   request_job_->SetClientID(device_id_);
   em::DeviceAutoEnrollmentRequest* request =
       request_job_->GetRequest()->mutable_auto_enrollment_request();
   request->set_remainder(remainder);
   request->set_modulus(INT64_C(1) << current_power_);
   request_job_->Start(
       base::Bind(&AutoEnrollmentClient::HandleRequestCompletion,
                  base::Unretained(this),
                  &AutoEnrollmentClient::OnBucketDownloadRequestCompletion));
 }
 
 void AutoEnrollmentClient::SendDeviceStateRequest() {
   ReportProgress(AUTO_ENROLLMENT_STATE_PENDING);
 
+  VLOG(1) << "State request for key: " << server_backed_state_key_;
   request_job_.reset(
       device_management_service_->CreateJob(
           DeviceManagementRequestJob::TYPE_DEVICE_STATE_RETRIEVAL,
           request_context_.get()));
   request_job_->SetClientID(device_id_);
   em::DeviceStateRetrievalRequest* request =
       request_job_->GetRequest()->mutable_device_state_retrieval_request();
   request->set_server_backed_state_key(server_backed_state_key_);
   request_job_->Start(
       base::Bind(&AutoEnrollmentClient::HandleRequestCompletion,
@@ skipping 73 matching lines @@
       return true;
     }
   } else {
     // Server should have sent down a list of hashes to try.
     has_server_state_ = IsIdHashInProtobuf(enrollment_response.hash());
     // Cache the current decision in local_state, so that it is reused in case
     // the device reboots before enrolling.
     local_state_->SetBoolean(prefs::kShouldAutoEnroll, has_server_state_);
     local_state_->SetInteger(prefs::kAutoEnrollmentPowerLimit, power_limit_);
     local_state_->CommitPendingWrite();
-    VLOG(1) << "Auto enrollment check complete, has_server_state_ = "
-            << has_server_state_;
+    VLOG(1) << "Received has_state=" << has_server_state_;
     progress = true;
   }
 
   // Bucket download done, update UMA.
   UpdateBucketDownloadTimingHistograms();
   return progress;
 }
 
 bool AutoEnrollmentClient::OnDeviceStateRequestCompletion(
     DeviceManagementStatus status,
@@ skipping 14 matching lines @@
       std::string restore_mode =
           ConvertRestoreMode(state_response.restore_mode());
       UpdateDict(dict.Get(), kDeviceStateRestoreMode, !restore_mode.empty(),
                  new base::Value(restore_mode));
 
       UpdateDict(dict.Get(), kDeviceStateDisabledMessage,
                  state_response.has_disabled_state(),
                  new base::Value(state_response.disabled_state().message()));
 
       // Logging as "WARNING" to make sure it's preserved in the logs.
-      LOG(WARNING) << "Restore mode: " << restore_mode;
+      LOG(WARNING) << "Received restore_mode=" << state_response.restore_mode();
     }
     local_state_->CommitPendingWrite();
     device_state_available_ = true;
     progress = true;
   }
 
   return progress;
 }
 
 bool AutoEnrollmentClient::IsIdHashInProtobuf(
@@ skipping 21 matching lines @@
   base::TimeDelta delta = kZero;
   if (!time_extra_start_.is_null())
     delta = now - time_extra_start_;
   // This samples |kZero| when there was no need for extra time, so that we can
   // measure the ratio of users that succeeded without needing a delay to the
   // total users going through OOBE.
   UMA_HISTOGRAM_CUSTOM_TIMES(kUMAExtraTime, delta, kMin, kMax, kBuckets);
 }
 
 }  // namespace policy