Move device requisition to EnterpriseEnrollmentHandlerChromeOS.

chrome/browser/chromeos/policy/device_cloud_policy_initializer.cc

 // Copyright 2014 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/device_cloud_policy_initializer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
@@ skipping 82 matching lines @@
 void DeviceCloudPolicyInitializer::StartEnrollment(
     DeviceManagementService* device_management_service,
     const std::string& auth_token,
     bool is_auto_enrollment,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& enrollment_callback) {
   CHECK(!enrollment_handler_);
 
   manager_->core()->Disconnect();
   enrollment_handler_.reset(new EnrollmentHandlerChromeOS(
+      local_state_,
       device_store_,
       install_attributes_,
       state_keys_broker_,
       CreateClient(device_management_service),
       background_task_runner_,
       auth_token,
       install_attributes_->GetDeviceId(),
       is_auto_enrollment,
-      manager_->GetDeviceRequisition(),
       allowed_device_modes,
       base::Bind(&DeviceCloudPolicyInitializer::EnrollmentCompleted,
                  base::Unretained(this),
                  enrollment_callback)));
   enrollment_handler_->StartEnrollment();
 }
 
 bool DeviceCloudPolicyInitializer::ShouldAutoStartEnrollment() const {
   std::string restore_mode = GetRestoreMode();
   if (restore_mode == kDeviceStateRestoreModeReEnrollmentRequested ||
@@ skipping 98 matching lines @@
     } else {
       service = enterprise_service_;
     }
     StartConnection(CreateClient(service));
   }
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
     scoped_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
-    manager_->StartConnection(client.Pass(), device_status_provider_.Pass());
+    manager_->StartConnection(client.Pass(),
+                              device_status_provider_.Pass(),
+                              local_state_);
 
   if (!on_connected_callback_.is_null()) {
     on_connected_callback_.Run();
     on_connected_callback_.Reset();
   }
 }
 
 std::string DeviceCloudPolicyInitializer::GetRestoreMode() const {
   const base::DictionaryValue* device_state_dict =
       local_state_->GetDictionary(prefs::kServerBackedDeviceState);
   std::string restore_mode;
   device_state_dict->GetString(kDeviceStateRestoreMode, &restore_mode);
   return restore_mode;
 }
 
 }  // namespace policy