settings: Make DeviceOAuth2TokenServiceFactory::Get() async

chrome/browser/chromeos/policy/enrollment_handler_chromeos.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/enrollment_handler_chromeos.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 35 matching lines @@
       background_task_runner_(background_task_runner),
       auth_token_(auth_token),
       client_id_(client_id),
       is_auto_enrollment_(is_auto_enrollment),
       requisition_(requisition),
       allowed_device_modes_(allowed_device_modes),
       completion_callback_(completion_callback),
       device_mode_(DEVICE_MODE_NOT_SET),
       enrollment_step_(STEP_PENDING),
       lockbox_init_duration_(0),
-      weak_factory_(this) {
+      lock_weak_factory_(this),
+      token_weak_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddNamespaceToFetch(PolicyNamespaceKey(
       dm_protocol::kChromeDevicePolicyType, std::string()));
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
@@ skipping 36 matching lines @@
                                CloudPolicyValidatorBase::TIMESTAMP_REQUIRED);
   if (install_attributes_->IsEnterpriseDevice())
     validator->ValidateDomain(install_attributes_->GetDomain());
   validator->ValidateDMToken(client->dm_token(),
                              CloudPolicyValidatorBase::DM_TOKEN_REQUIRED);
   validator->ValidatePolicyType(dm_protocol::kChromeDevicePolicyType);
   validator->ValidatePayload();
   validator->ValidateInitialKey();
   validator.release()->StartValidation(
       base::Bind(&EnrollmentHandlerChromeOS::PolicyValidated,
-                 weak_factory_.GetWeakPtr()));
+                 lock_weak_factory_.GetWeakPtr()));
 }
 
 void EnrollmentHandlerChromeOS::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
   DCHECK_EQ(client_.get(), client);
 
   if (enrollment_step_ == STEP_REGISTRATION && client_->is_registered()) {
     enrollment_step_ = STEP_POLICY_FETCH,
     device_mode_ = client_->device_mode();
     if (device_mode_ == DEVICE_MODE_NOT_SET)
@@ skipping 30 matching lines @@
 
 void EnrollmentHandlerChromeOS::OnStoreLoaded(CloudPolicyStore* store) {
   DCHECK_EQ(store_, store);
 
   if (enrollment_step_ == STEP_LOADING_STORE) {
     // If the |store_| wasn't initialized when StartEnrollment() was
     // called, then AttemptRegistration() bails silently.  This gets
     // registration rolling again after the store finishes loading.
     AttemptRegistration();
   } else if (enrollment_step_ == STEP_STORE_POLICY) {
-    // Store the robot API auth refresh token.
-    // Currently optional, so always return success.
-    chromeos::DeviceOAuth2TokenService* token_service =
-        chromeos::DeviceOAuth2TokenServiceFactory::Get();
-    if (token_service && !robot_refresh_token_.empty()) {
-      token_service->SetAndSaveRefreshToken(robot_refresh_token_);
+    chromeos::DeviceOAuth2TokenServiceFactory::Get(
+        base::Bind(&EnrollmentHandlerChromeOS::DidGetTokenService,
+                   token_weak_factory_.GetWeakPtr()));
+  }
+}
 
-    }
-    ReportResult(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS));
-  }
+void EnrollmentHandlerChromeOS::DidGetTokenService(
+    chromeos::DeviceOAuth2TokenService* token_service) {
+  // Store the robot API auth refresh token.
+  // Currently optional, so always return success.
+  if (token_service && !robot_refresh_token_.empty())
+    token_service->SetAndSaveRefreshToken(robot_refresh_token_);
+  ReportResult(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS));
 }
 
 void EnrollmentHandlerChromeOS::OnStoreError(CloudPolicyStore* store) {
   DCHECK_EQ(store_, store);
   ReportResult(EnrollmentStatus::ForStoreError(store_->status(),
                                                store_->validation_status()));
 }
 
 void EnrollmentHandlerChromeOS::AttemptRegistration() {
   CHECK_EQ(STEP_LOADING_STORE, enrollment_step_);
@@ skipping 80 matching lines @@
   CHECK_EQ(STEP_ROBOT_AUTH_REFRESH, enrollment_step_);
   DoLockDeviceStep();
 }
 
 void EnrollmentHandlerChromeOS::StartLockDevice(
     const std::string& user,
     DeviceMode device_mode,
     const std::string& device_id) {
   CHECK_EQ(STEP_LOCK_DEVICE, enrollment_step_);
   // Since this method is also called directly.
-  weak_factory_.InvalidateWeakPtrs();
+  lock_weak_factory_.InvalidateWeakPtrs();
 
   install_attributes_->LockDevice(
       user, device_mode, device_id,
       base::Bind(&EnrollmentHandlerChromeOS::HandleLockDeviceResult,
-                 weak_factory_.GetWeakPtr(),
+                 lock_weak_factory_.GetWeakPtr(),
                  user,
                  device_mode,
                  device_id));
 }
 
 void EnrollmentHandlerChromeOS::HandleLockDeviceResult(
     const std::string& user,
     DeviceMode device_mode,
     const std::string& device_id,
     EnterpriseInstallAttributes::LockResult lock_result) {
   CHECK_EQ(STEP_LOCK_DEVICE, enrollment_step_);
   switch (lock_result) {
     case EnterpriseInstallAttributes::LOCK_SUCCESS:
       enrollment_step_ = STEP_STORE_POLICY;
       store_->InstallInitialPolicy(*policy_);
       return;
     case EnterpriseInstallAttributes::LOCK_NOT_READY:
       // We wait up to |kLockRetryTimeoutMs| milliseconds and if it hasn't
       // succeeded by then show an error to the user and stop the enrollment.
       if (lockbox_init_duration_ < kLockRetryTimeoutMs) {
         // InstallAttributes not ready yet, retry later.
         LOG(WARNING) << "Install Attributes not ready yet will retry in "
                      << kLockRetryIntervalMs << "ms.";
         base::MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&EnrollmentHandlerChromeOS::StartLockDevice,
-                       weak_factory_.GetWeakPtr(),
+                       lock_weak_factory_.GetWeakPtr(),
                        user, device_mode, device_id),
             base::TimeDelta::FromMilliseconds(kLockRetryIntervalMs));
         lockbox_init_duration_ += kLockRetryIntervalMs;
       } else {
         ReportResult(EnrollmentStatus::ForStatus(
             EnrollmentStatus::STATUS_LOCK_TIMEOUT));
       }
       return;
     case EnterpriseInstallAttributes::LOCK_BACKEND_ERROR:
       ReportResult(EnrollmentStatus::ForStatus(
           EnrollmentStatus::STATUS_LOCK_ERROR));
       return;
     case EnterpriseInstallAttributes::LOCK_WRONG_USER:
       LOG(ERROR) << "Enrollment cannot proceed because the InstallAttrs "
                  << "has been locked already!";
       ReportResult(EnrollmentStatus::ForStatus(
           EnrollmentStatus::STATUS_LOCK_WRONG_USER));
       return;
   }
 
   NOTREACHED() << "Invalid lock result " << lock_result;
   ReportResult(EnrollmentStatus::ForStatus(
       EnrollmentStatus::STATUS_LOCK_ERROR));
 }
 
 void EnrollmentHandlerChromeOS::Stop() {
   if (client_.get())
     client_->RemoveObserver(this);
   enrollment_step_ = STEP_FINISHED;
-  weak_factory_.InvalidateWeakPtrs();
+  lock_weak_factory_.InvalidateWeakPtrs();
   completion_callback_.Reset();
 }
 
 void EnrollmentHandlerChromeOS::ReportResult(EnrollmentStatus status) {
   EnrollmentCallback callback = completion_callback_;
   Stop();
 
   if (status.status() != EnrollmentStatus::STATUS_SUCCESS) {
     LOG(WARNING) << "Enrollment failed: " << status.status()
                  << " " << status.client_status()
                  << " " << status.validation_status()
                  << " " << status.store_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy