Mixed Licenses Enrollment

components/policy/core/common/cloud/cloud_policy_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 "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 111 matching lines @@
 // Sets the client ID or generate a new one. A new one is intentionally
 // generated on each new registration request in order to preserve privacy.
 // Reusing IDs would mean the server could track clients by their registration
 // attempts.
 void CloudPolicyClient::SetClientId(const std::string& client_id) {
   client_id_ = client_id.empty() ?  base::GenerateGUID() : client_id;
 }
 
 void CloudPolicyClient::Register(em::DeviceRegisterRequest::Type type,
                                  em::DeviceRegisterRequest::Flavor flavor,
+                                 em::LicenseType license_type,
                                  const std::string& auth_token,
                                  const std::string& client_id,
                                  const std::string& requisition,
                                  const std::string& current_state_key) {
   DCHECK(service_);
   DCHECK(!auth_token.empty());
   DCHECK(!is_registered());
 
   SetClientId(client_id);
 
@@ skipping 10 matching lines @@
   request->set_type(type);
   if (!machine_id_.empty())
     request->set_machine_id(machine_id_);
   if (!machine_model_.empty())
     request->set_machine_model(machine_model_);
   if (!requisition.empty())
     request->set_requisition(requisition);
   if (!current_state_key.empty())
     request->set_server_backed_state_key(current_state_key);
   request->set_flavor(flavor);
+  if (license_type != em::LicenseType::UNDEFINED)
+    request->set_license_type(license_type);
 
   policy_fetch_request_job_->SetRetryCallback(
       base::Bind(&CloudPolicyClient::OnRetryRegister,
                  weak_ptr_factory_.GetWeakPtr()));
 
   policy_fetch_request_job_->Start(
       base::Bind(&CloudPolicyClient::OnRegisterCompleted,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CloudPolicyClient::RegisterWithCertificate(
     em::DeviceRegisterRequest::Type type,
     em::DeviceRegisterRequest::Flavor flavor,
+    em::LicenseType license_type,
     const std::string& pem_certificate_chain,
     const std::string& client_id,
     const std::string& requisition,
     const std::string& current_state_key) {
   DCHECK(signing_service_);
   DCHECK(service_);
   DCHECK(!is_registered());
 
   SetClientId(client_id);
 
   em::CertificateBasedDeviceRegistrationData data;
   data.set_certificate_type(em::CertificateBasedDeviceRegistrationData::
       ENTERPRISE_ENROLLMENT_CERTIFICATE);
   data.set_device_certificate(pem_certificate_chain);
 
   em::DeviceRegisterRequest* request = data.mutable_device_register_request();
   if (!client_id.empty())
     request->set_reregister(true);
   request->set_type(type);
   if (!machine_id_.empty())
     request->set_machine_id(machine_id_);
   if (!machine_model_.empty())
     request->set_machine_model(machine_model_);
   if (!requisition.empty())
     request->set_requisition(requisition);
   if (!current_state_key.empty())
     request->set_server_backed_state_key(current_state_key);
   request->set_flavor(flavor);
+  if (license_type != em::LicenseType::UNDEFINED)
+    request->set_license_type(license_type);
 
   signing_service_->SignData(data.SerializeAsString(),
       base::Bind(&CloudPolicyClient::OnRegisterWithCertificateRequestSigned,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CloudPolicyClient::OnRegisterWithCertificateRequestSigned(bool success,
     em::SignedData signed_data) {
   if (!success) {
     const em::DeviceManagementResponse response;
@@ skipping 657 matching lines @@
   for (auto& observer : observers_)
     observer.OnRobotAuthCodesFetched(this);
 }
 
 void CloudPolicyClient::NotifyClientError() {
   for (auto& observer : observers_)
     observer.OnClientError(this);
 }
 
 }  // namespace policy