Mixed Licenses Enrollment

chrome/browser/chromeos/login/enrollment/enrollment_screen.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/login/enrollment/enrollment_screen.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
     UMA_HISTOGRAM_CUSTOM_TIMES(                            \
       (histogram_name),                                    \
       (elapsed_timer)->Elapsed(),                          \
       base::TimeDelta::FromMilliseconds(100) /* min */,    \
       base::TimeDelta::FromMinutes(15) /* max */,          \
       100 /* bucket_count */);                             \
   } while (0)
 
 namespace {
 
-const char * const kMetricEnrollmentTimeCancel =
+const char* const kMetricEnrollmentTimeCancel =
     "Enterprise.EnrollmentTime.Cancel";
-const char * const kMetricEnrollmentTimeFailure =
+const char* const kMetricEnrollmentTimeFailure =
     "Enterprise.EnrollmentTime.Failure";
-const char * const kMetricEnrollmentTimeSuccess =
+const char* const kMetricEnrollmentTimeSuccess =
     "Enterprise.EnrollmentTime.Success";
 
+const char* const kLicenseTypePerpetual = "perpetual";
+const char* const kLicenseTypeAnnual = "annual";
+const char* const kLicenseTypeKiosk = "kiosk";
+
 // Retry policy constants.
 constexpr int kInitialDelayMS = 4 * 1000;  // 4 seconds
 constexpr double kMultiplyFactor = 1.5;
 constexpr double kJitterFactor = 0.1;           // +/- 10% jitter
 constexpr int64_t kMaxDelayMS = 8 * 60 * 1000;  // 8 minutes
 
+::policy::LicenseType GetLicenseTypeById(const std::string& id) {
+  if (id == kLicenseTypePerpetual)
+    return ::policy::LicenseType::PERPETUAL;
+  if (id == kLicenseTypeAnnual)
+    return ::policy::LicenseType::ANNUAL;
+  if (id == kLicenseTypeKiosk)
+    return ::policy::LicenseType::KIOSK;
+  return ::policy::LicenseType::UNKNOWN;
+}
+
+std::string GetLicenseIdByType(::policy::LicenseType type) {
+  switch (type) {
+    case ::policy::LicenseType::PERPETUAL:
+      return kLicenseTypePerpetual;
+    case ::policy::LicenseType::ANNUAL:
+      return kLicenseTypeAnnual;
+    case ::policy::LicenseType::KIOSK:
+      return kLicenseTypeKiosk;
+    default:
+      NOTREACHED();
+      return std::string();
+  }
+}
+
 }  // namespace
 
 namespace chromeos {
 
 // static
 EnrollmentScreen* EnrollmentScreen::Get(ScreenManager* manager) {
   return static_cast<EnrollmentScreen*>(
       manager->GetScreen(OobeScreen::SCREEN_OOBE_ENROLLMENT));
 }
 
@@ skipping 125 matching lines @@
   enrolling_user_domain_ = gaia::ExtractDomainName(user);
   UMA(enrollment_failed_once_ ? policy::kMetricEnrollmentRestarted
                               : policy::kMetricEnrollmentStarted);
 
   view_->ShowEnrollmentSpinnerScreen();
   CreateEnrollmentHelper();
   enrollment_helper_->EnrollUsingAuthCode(
       auth_code, shark_controller_ != nullptr /* fetch_additional_token */);
 }
 
-void EnrollmentScreen::OnLicenseTypeSelected(const std::string& license_type) {}
+void EnrollmentScreen::OnLicenseTypeSelected(const std::string& license_type) {
+  view_->ShowEnrollmentSpinnerScreen();
+  ::policy::LicenseType license = GetLicenseTypeById(license_type);
+  CHECK(license != ::policy::LicenseType::UNKNOWN) << "license_type = UNKNOWN";
+  enrollment_helper_->UseLicenseType(license);
+}
 
 void EnrollmentScreen::OnRetry() {
   retry_task_.Cancel();
   ProcessRetry();
 }
 
 void EnrollmentScreen::AutomaticRetry() {
   retry_backoff_->InformOfRequest(false);
   retry_task_.Reset(base::Bind(&EnrollmentScreen::ProcessRetry,
                                weak_ptr_factory_.GetWeakPtr()));
@@ skipping 42 matching lines @@
 
 void EnrollmentScreen::OnAdJoined(const std::string& realm) {
   std::move(on_joined_callback_).Run(realm);
 }
 
 void EnrollmentScreen::OnAuthError(const GoogleServiceAuthError& error) {
   RecordEnrollmentErrorMetrics();
   view_->ShowAuthError(error);
 }
 
+void EnrollmentScreen::OnMultipleLicensesAvailable(
+    const EnrollmentLicenseMap& licenses) {
+  base::DictionaryValue license_dict;
+  for (const auto& it : licenses)
+    license_dict.SetInteger(GetLicenseIdByType(it.first), it.second);
+  view_->ShowLicenseTypeSelectionScreen(license_dict);
+}
+
 void EnrollmentScreen::OnEnrollmentError(policy::EnrollmentStatus status) {
   // TODO(pbond): remove this LOG once http://crbug.com/586961 is fixed.
   LOG(WARNING) << "Enrollment error occured: status=" << status.status()
                << " http status=" << status.http_status()
                << " DM status=" << status.client_status();
   RecordEnrollmentErrorMetrics();
   // If the DM server does not have a device pre-provisioned for attestation-
   // based enrollment and we have a fallback authentication, show it.
   if (status.status() == policy::EnrollmentStatus::REGISTRATION_FAILED &&
       status.client_status() == policy::DM_STATUS_SERVICE_DEVICE_NOT_FOUND &&
@@ skipping 108 matching lines @@
   if (elapsed_timer_)
     UMA_ENROLLMENT_TIME(kMetricEnrollmentTimeFailure, elapsed_timer_);
 }
 
 void EnrollmentScreen::JoinDomain(OnDomainJoinedCallback on_joined_callback) {
   on_joined_callback_ = std::move(on_joined_callback);
   view_->ShowAdJoin();
 }
 
 }  // namespace chromeos