Wire the device requisition parameter for enterprise enrollment.

chrome/browser/chromeos/policy/device_cloud_policy_manager_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/device_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "chrome/browser/chromeos/attestation/attestation_policy_observer.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/enrollment_handler_chromeos.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/device_management_service.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/chromeos_constants.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // MachineInfo key names.
 const char kMachineInfoSystemHwqual[] = "hardware_class";
 
@@ skipping 13 matching lines @@
 //
 // TODO(mnissler): Move serial_number back to the top once the server side uses
 // the correct serial number.
 const char* kMachineInfoSerialNumberKeys[] = {
   "Product_S/N",    // Lumpy/Alex devices
   "serial_number",  // VPD v2+ devices
   "Product_SN",     // Mario
   "sn",             // old ZGB devices (more recent ones use serial_number)
 };
 
+// Fetches a machine statics from StatisticsProvider, returns an empty string on
+// failure.
+std::string GetMachineStatistic(const std::string& key) {
+  std::string value;
+  chromeos::system::StatisticsProvider* provider =
+      chromeos::system::StatisticsProvider::GetInstance();
+  if (!provider->GetMachineStatistic(key, &value))
+    LOG(WARNING) << "Failed to get machine statistic " << key;
+
+  return value;
+}
+
 }  // namespace
 
 DeviceCloudPolicyManagerChromeOS::DeviceCloudPolicyManagerChromeOS(
     scoped_ptr<DeviceCloudPolicyStoreChromeOS> store,
     EnterpriseInstallAttributes* install_attributes)
     : CloudPolicyManager(
           PolicyNamespaceKey(dm_protocol::kChromeDevicePolicyType,
                              std::string()),
           store.get()),
       device_store_(store.Pass()),
@@ skipping 19 matching lines @@
 }
 
 void DeviceCloudPolicyManagerChromeOS::StartEnrollment(
     const std::string& auth_token,
     bool is_auto_enrollment,
     const AllowedDeviceModes& allowed_device_modes,
     const EnrollmentCallback& callback) {
   CHECK(device_management_service_);
   core()->Disconnect();
 
+  if (requisition_.empty())
+    requisition_ = GetMachineStatistic(chromeos::kOemDeviceRequisitionKey);
+
   enrollment_handler_.reset(
       new EnrollmentHandlerChromeOS(
           device_store_.get(), install_attributes_, CreateClient(), auth_token,
           install_attributes_->GetDeviceId(), is_auto_enrollment,
-          allowed_device_modes,
+          requisition_, allowed_device_modes,
           base::Bind(&DeviceCloudPolicyManagerChromeOS::EnrollmentCompleted,
                      base::Unretained(this), callback)));
   enrollment_handler_->StartEnrollment();
 }
 
 void DeviceCloudPolicyManagerChromeOS::CancelEnrollment() {
   if (enrollment_handler_.get()) {
     enrollment_handler_.reset();
     StartIfManaged();
   }
@@ skipping 25 matching lines @@
   }
 
   if (machine_id.empty())
     LOG(WARNING) << "Failed to get machine id.";
 
   return machine_id;
 }
 
 // static
 std::string DeviceCloudPolicyManagerChromeOS::GetMachineModel() {
-  std::string machine_model;
-  chromeos::system::StatisticsProvider* provider =
-      chromeos::system::StatisticsProvider::GetInstance();
-  if (!provider->GetMachineStatistic(kMachineInfoSystemHwqual, &machine_model))
-    LOG(WARNING) << "Failed to get machine model.";
-
-  return machine_model;
+  return GetMachineStatistic(kMachineInfoSystemHwqual);
 }
 
 scoped_ptr<CloudPolicyClient> DeviceCloudPolicyManagerChromeOS::CreateClient() {
   return make_scoped_ptr(
       new CloudPolicyClient(GetMachineID(), GetMachineModel(),
                             USER_AFFILIATION_NONE,
                             device_status_provider_.get(),
                             device_management_service_));
 }
 
@@ skipping 25 matching lines @@
     core()->Connect(CreateClient());
     core()->StartRefreshScheduler();
     core()->TrackRefreshDelayPref(local_state_,
                                   prefs::kDevicePolicyRefreshRate);
     attestation_policy_observer_.reset(
         new chromeos::attestation::AttestationPolicyObserver(client()));
   }
 }
 
 }  // namespace policy