Add UI components for license type selection in ChromeOS login UI.

chrome/browser/ui/webui/chromeos/login/enrollment_screen_handler.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/ui/webui/chromeos/login/enrollment_screen_handler.h"
 
 #include <algorithm>
 
 #include "ash/system/devicetype_utils.h"
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 namespace {
 
 const char kJsScreenPath[] = "login.OAuthEnrollmentScreen";
 
 // Enrollment step names.
 const char kEnrollmentStepSignin[] = "signin";
 const char kEnrollmentStepAdJoin[] = "ad-join";
+const char kEnrollmentStepPickLicense[] = "license";
 const char kEnrollmentStepSuccess[] = "success";
 const char kEnrollmentStepWorking[] = "working";
 
 // Enrollment mode constants used in the UI. This needs to be kept in sync with
 // oobe_screen_oauth_enrollment.js.
 const char kEnrollmentModeUIForced[] = "forced";
 const char kEnrollmentModeUIManual[] = "manual";
 const char kEnrollmentModeUIRecovery[] = "recovery";
 
 // Converts |mode| to a mode identifier for the UI.
@@ skipping 85 matching lines @@
   AddCallback("oauthEnrollAdCompleteLogin",
               &EnrollmentScreenHandler::HandleAdCompleteLogin);
   AddCallback("oauthEnrollRetry",
               &EnrollmentScreenHandler::HandleRetry);
   AddCallback("frameLoadingCompleted",
               &EnrollmentScreenHandler::HandleFrameLoadingCompleted);
   AddCallback("oauthEnrollAttributes",
               &EnrollmentScreenHandler::HandleDeviceAttributesProvided);
   AddCallback("oauthEnrollOnLearnMore",
               &EnrollmentScreenHandler::HandleOnLearnMore);
+  AddCallback("onLicenseTypeSelected",
+              &EnrollmentScreenHandler::HandleLicenseTypeSelected);
 }
 
 // EnrollmentScreenHandler
 //      EnrollmentScreenActor implementation -----------------------------------
 
 void EnrollmentScreenHandler::SetParameters(
     Controller* controller,
     const policy::EnrollmentConfig& config) {
   CHECK(config.should_enroll());
   controller_ = controller;
   config_ = config;
 }
 
 void EnrollmentScreenHandler::Show() {
   if (!page_is_ready())
     show_on_init_ = true;
   else
     DoShow();
 }
 
 void EnrollmentScreenHandler::Hide() {
 }
 
 void EnrollmentScreenHandler::ShowSigninScreen() {
   observe_network_failure_ = true;
   ShowStep(kEnrollmentStepSignin);
 }
 
+void EnrollmentScreenHandler::ShowLicenseTypeSelectionScreen(
+    const base::DictionaryValue& license_types) {
+  CallJS("setAvailableLicenseTypes", license_types);
+  ShowStep(kEnrollmentStepPickLicense);
+}
+
 void EnrollmentScreenHandler::ShowAdJoin() {
   observe_network_failure_ = false;
   if (!authpolicy_login_helper_)
     authpolicy_login_helper_ = base::MakeUnique<AuthPolicyLoginHelper>();
   ShowStep(kEnrollmentStepAdJoin);
 }
 
 void EnrollmentScreenHandler::ShowAttributePromptScreen(
     const std::string& asset_id,
     const std::string& location) {
@@ skipping 161 matching lines @@
                 false);
       return;
     case policy::EnrollmentStatus::ACTIVE_DIRECTORY_POLICY_FETCH_FAILED:
       ShowError(IDS_ENTERPRISE_ENROLLMENT_ERROR_ACTIVE_DIRECTORY_POLICY_FETCH,
                 false);
       return;
     case policy::EnrollmentStatus::DM_TOKEN_STORE_FAILED:
       ShowError(IDS_ENTERPRISE_ENROLLMENT_ERROR_SAVE_DEVICE_CONFIGURATION,
                 false);
       return;
+    case policy::EnrollmentStatus::LICENSE_REQUEST_FAILED:
+      ShowError(IDS_ENTERPRISE_ENROLLMENT_ERROR_LICENSE_REQUEST, false);
+      return;
   }
   NOTREACHED();
 }
 
 // EnrollmentScreenHandler BaseScreenHandler implementation -----
 
 void EnrollmentScreenHandler::Initialize() {
   if (show_on_init_) {
     Show();
     show_on_init_ = false;
@@ skipping 26 matching lines @@
   builder->Add("oauthEnrollAdMachineNameInput",
                IDS_AD_MACHINE_NAME_INPUT_LABEL);
   builder->Add("oauthEnrollAdDomainJoinWelcomeMessage",
                IDS_AD_DOMAIN_JOIN_WELCOME_MESSAGE);
   builder->Add("adLoginUsername", IDS_AD_LOGIN_USER);
   builder->Add("adLoginInvalidUsername", IDS_AD_INVALID_USERNAME);
   builder->Add("adLoginPassword", IDS_AD_LOGIN_PASSWORD);
   builder->Add("adLoginInvalidPassword", IDS_AD_INVALID_PASSWORD);
   builder->Add("adJoinErrorMachineNameInvalid", IDS_AD_MACHINENAME_INVALID);
   builder->Add("adJoinErrorMachineNameTooLong", IDS_AD_MACHINENAME_TOO_LONG);
+  builder->Add("licenseSelectionCardTitle",
+               IDS_ENTERPRISE_ENROLLMENT_LICENSE_SELECTION);
+  builder->Add("licenseSelectionCardExplanation",
+               IDS_ENTERPRISE_ENROLLMENT_LICENSE_SELECTION_EXPLANATION);
+  builder->Add("perpetualLicenseTypeTitle",
+               IDS_ENTERPRISE_ENROLLMENT_PERPETUAL_LICENSE_TYPE);
+  builder->Add("annualLicenseTypeTitle",
+               IDS_ENTERPRISE_ENROLLMENT_ANNUAL_LICENSE_TYPE);
+  builder->Add("kioskLicenseTypeTitle",
+               IDS_ENTERPRISE_ENROLLMENT_KIOSK_LICENSE_TYPE);
+  builder->Add("licenseCountTemplate",
+               IDS_ENTERPRISE_ENROLLMENT_LICENSES_REMAINING_TEMPLATE);
 }
 
 bool EnrollmentScreenHandler::IsOnEnrollmentScreen() const {
   return (GetCurrentScreen() == kScreenId);
 }
 
 bool EnrollmentScreenHandler::IsEnrollmentScreenHiddenByError() const {
   return (GetCurrentScreen() == OobeScreen::SCREEN_ERROR_MESSAGE &&
           error_screen_->GetParentScreen() == kScreenId);
 }
@@ skipping 208 matching lines @@
     const std::string& location) {
   controller_->OnDeviceAttributeProvided(asset_id, location);
 }
 
 void EnrollmentScreenHandler::HandleOnLearnMore() {
   if (!help_app_.get())
     help_app_ = new HelpAppLauncher(GetNativeWindow());
   help_app_->ShowHelpTopic(HelpAppLauncher::HELP_DEVICE_ATTRIBUTES);
 }
 
+void EnrollmentScreenHandler::HandleLicenseTypeSelected(
+    const std::string& licenseType) {
+  controller_->OnLicenseTypeSelected(licenseType);
+}
+
 void EnrollmentScreenHandler::ShowStep(const char* step) {
   CallJS("showStep", std::string(step));
 }
 
 void EnrollmentScreenHandler::ShowError(int message_id, bool retry) {
   ShowErrorMessage(l10n_util::GetStringUTF8(message_id), retry);
 }
 
 void EnrollmentScreenHandler::ShowErrorForDevice(int message_id, bool retry) {
   ShowErrorMessage(
@@ skipping 25 matching lines @@
 
   ShowScreenWithData(OobeScreen::SCREEN_OOBE_ENROLLMENT, &screen_data);
   if (first_show_) {
     first_show_ = false;
     UpdateStateInternal(NetworkError::ERROR_REASON_UPDATE, true);
   }
   histogram_helper_->OnScreenShow();
 }
 
 }  // namespace chromeos