Mixed Licenses Enrollment

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 113 matching lines @@
       state_keys_broker_(state_keys_broker),
       attestation_flow_(attestation_flow),
       client_(std::move(client)),
       background_task_runner_(background_task_runner),
       ad_join_delegate_(ad_join_delegate),
       enrollment_config_(enrollment_config),
       auth_token_(auth_token),
       client_id_(client_id),
       requisition_(requisition),
       completion_callback_(completion_callback),
+      license_type_(enterprise_management::LicenseType::UNDEFINED),

[emaxx, 2017/07/21 12:57:30]

nit: s/enterprise_management/em/

[Denis Kuznetsov (DE-MUC), 2017/07/25 21:51:06]

Done.

       enrollment_step_(STEP_PENDING),
       weak_ptr_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
   CHECK((enrollment_config_.mode == EnrollmentConfig::MODE_ATTESTATION ||
          enrollment_config_.mode ==
              EnrollmentConfig::MODE_ATTESTATION_FORCED) == auth_token_.empty());
   CHECK(enrollment_config_.auth_mechanism !=
             EnrollmentConfig::AUTH_MECHANISM_ATTESTATION ||
         attestation_flow_);
   store_->AddObserver(this);
   client_->AddObserver(this);
   client_->AddPolicyTypeToFetch(dm_protocol::kChromeDevicePolicyType,
                                 std::string());
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
   store_->RemoveObserver(this);
 }
 
+void EnrollmentHandlerChromeOS::CheckAvailableLicenses(
+    const LicenseSelectionCallback& license_callback) {
+  CHECK_EQ(STEP_PENDING, enrollment_step_);
+  license_selection_callback_ = license_callback;
+  client_->RequestAvailableLicenses(
+      auth_token_,
+      base::Bind(&EnrollmentHandlerChromeOS::HandleAvailableLicensesResult,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void EnrollmentHandlerChromeOS::HandleAvailableLicensesResult(
+    bool success,
+    const policy::CloudPolicyClient::LicenseMap& license_map) {
+  if (!success) {
+    ReportResult(
+        EnrollmentStatus::ForStatus(EnrollmentStatus::LICENSE_REQUEST_FAILED));
+    return;
+  }
+  if (!license_selection_callback_.is_null()) {

[emaxx, 2017/07/21 12:57:30]

nit: It's possible to write it simply as:
  if (license_selection_callback_) {

[Denis Kuznetsov (DE-MUC), 2017/07/25 21:51:06]

Done.

+    license_selection_callback_.Run(license_map);
+  }
+}
+
+void EnrollmentHandlerChromeOS::StartEnrollmentWithLicense(
+    ::policy::LicenseType license_type) {
+  CHECK_EQ(STEP_PENDING, enrollment_step_);
+  CHECK(license_type != ::policy::LicenseType::UNKNOWN);

[emaxx, 2017/07/21 12:57:30]

nit: Use CHECK_NE?

[Denis Kuznetsov (DE-MUC), 2017/07/25 21:51:06]

Done.

+  switch (license_type) {
+    case ::policy::LicenseType::PERPETUAL:
+      license_type_ = ::enterprise_management::LicenseType::CDM_PERPETUAL;

[emaxx, 2017/07/21 12:57:30]

nit: s/enterprise_management/em/

[Denis Kuznetsov (DE-MUC), 2017/07/25 21:51:06]

Done.

+      return;

[emaxx, 2017/07/21 12:57:30]

This method is called "StartEnrollment...", but does nothing except updating the
data field. Shouldn't the enrollment be started?

[Denis Kuznetsov (DE-MUC), 2017/07/25 21:51:06]

Done.

+    case ::policy::LicenseType::ANNUAL:
+      license_type_ = ::enterprise_management::LicenseType::CDM_ANNUAL;
+      return;
+    case ::policy::LicenseType::KIOSK:
+      license_type_ = ::enterprise_management::LicenseType::KIOSK;
+      return;
+    case ::policy::LicenseType::UNKNOWN:
+      NOTREACHED();
+  }
+}
+
 void EnrollmentHandlerChromeOS::StartEnrollment() {
   CHECK_EQ(STEP_PENDING, enrollment_step_);
   SetStep(STEP_STATE_KEYS);
 
   if (client_->machine_id().empty()) {
     LOG(ERROR) << "Machine id empty.";
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::NO_MACHINE_IDENTIFICATION));
     return;
   }
@@ skipping 150 matching lines @@
     // after the CloudPolicyStore has initialized.
     return;
   }
   SetStep(STEP_REGISTRATION);
   if (enrollment_config_.is_mode_attestation()) {
     StartAttestationBasedEnrollmentFlow();
   } else {
     client_->Register(
         em::DeviceRegisterRequest::DEVICE,
         EnrollmentModeToRegistrationFlavor(enrollment_config_.mode),
-        auth_token_, client_id_, requisition_, current_state_key_);
+        license_type_, auth_token_, client_id_, requisition_,
+        current_state_key_);
   }
 }
 
 void EnrollmentHandlerChromeOS::StartAttestationBasedEnrollmentFlow() {
   const chromeos::attestation::AttestationFlow::CertificateCallback callback =
       base::Bind(
           &EnrollmentHandlerChromeOS::HandleRegistrationCertificateResult,
           weak_ptr_factory_.GetWeakPtr());
   attestation_flow_->GetCertificate(
       chromeos::attestation::PROFILE_ENTERPRISE_ENROLLMENT_CERTIFICATE,
       EmptyAccountId(), "" /* request_origin */, false /* force_new_key */,
       callback);
 }
 
 void EnrollmentHandlerChromeOS::HandleRegistrationCertificateResult(
     bool success,
     const std::string& pem_certificate_chain) {
   if (success)
     client_->RegisterWithCertificate(
         em::DeviceRegisterRequest::DEVICE,
         EnrollmentModeToRegistrationFlavor(enrollment_config_.mode),
-        pem_certificate_chain, client_id_, requisition_, current_state_key_);
+        license_type_, pem_certificate_chain, client_id_, requisition_,
+        current_state_key_);
   else
     ReportResult(EnrollmentStatus::ForStatus(
         EnrollmentStatus::REGISTRATION_CERT_FETCH_FAILED));
 }
 
 void EnrollmentHandlerChromeOS::HandlePolicyValidationResult(
     DeviceCloudPolicyValidator* validator) {
   DCHECK_EQ(STEP_VALIDATION, enrollment_step_);
   if (validator->success()) {
     std::string username = validator->policy_data()->username();
@@ skipping 270 matching lines @@
   // After that, the enrollment flow continues in one of the OnStore* observers.
   store_->Load();
 }
 
 void EnrollmentHandlerChromeOS::Stop() {
   if (client_.get())
     client_->RemoveObserver(this);
   SetStep(STEP_FINISHED);
   weak_ptr_factory_.InvalidateWeakPtrs();
   completion_callback_.Reset();
+  license_selection_callback_.Reset();
 }
 
 void EnrollmentHandlerChromeOS::ReportResult(EnrollmentStatus status) {
   EnrollmentCallback callback = completion_callback_;
   Stop();
 
   if (status.status() != EnrollmentStatus::SUCCESS) {
     LOG(WARNING) << "Enrollment failed: " << status.status()
                  << ", client: " << status.client_status()
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 void EnrollmentHandlerChromeOS::SetStep(EnrollmentStep step) {
   DCHECK_LE(enrollment_step_, step);
   VLOG(1) << "Step: " << step;
   enrollment_step_ = step;
 }
 
 }  // namespace policy