Added OOBE Asset / Naming prompt

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 22 matching lines @@
 
 namespace chromeos {
 namespace {
 
 const char kJsScreenPath[] = "login.OAuthEnrollmentScreen";
 
 // Enrollment step names.
 const char kEnrollmentStepSignin[] = "signin";
 const char kEnrollmentStepSuccess[] = "success";
 const char kEnrollmentStepWorking[] = "working";
+const char kEnrollmentStepNaming[] = "naming";
 
 // 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";
 
 // Enrollment help topic IDs.
 const int kEnrollmentHelpTopicRegular = 6142332;
 const int kEnrollmentHelpTopicServerTriggered = 4631259;
@@ skipping 88 matching lines @@
 
 void EnrollmentScreenHandler::RegisterMessages() {
   AddCallback("oauthEnrollClose",
               &EnrollmentScreenHandler::HandleClose);
   AddCallback("oauthEnrollCompleteLogin",
               &EnrollmentScreenHandler::HandleCompleteLogin);
   AddCallback("oauthEnrollRetry",
               &EnrollmentScreenHandler::HandleRetry);
   AddCallback("frameLoadingCompleted",
               &EnrollmentScreenHandler::HandleFrameLoadingCompleted);
+  AddCallback("oauthEnrollNaming",
+              &EnrollmentScreenHandler::HandleDeviceNaming);
 }
 
 // EnrollmentScreenHandler
 //      EnrollmentScreenActor implementation -----------------------------------
 
 void EnrollmentScreenHandler::SetParameters(
     Controller* controller,
     const policy::EnrollmentConfig& config) {
   CHECK_NE(policy::EnrollmentConfig::MODE_NONE, config.mode);
   controller_ = controller;
@@ skipping 16 matching lines @@
 }
 
 void EnrollmentScreenHandler::Hide() {
 }
 
 void EnrollmentScreenHandler::ShowSigninScreen() {
   observe_network_failure_ = true;
   ShowStep(kEnrollmentStepSignin);
 }
 
+void EnrollmentScreenHandler::ShowDeviceNamingScreen() {
+  base::DictionaryValue data;
+
+  // TODO: add existing Asset ID and Location values.
+  data.SetString("device_asset_id", "Asset Identifier");
+  data.SetString("device_location", "Location");
+
+  OnBeforeShowNaming(data);
+  ShowStep(kEnrollmentStepNaming);
+}
+
 void EnrollmentScreenHandler::ShowEnrollmentSpinnerScreen() {
   ShowStep(kEnrollmentStepWorking);
 }
 
 void EnrollmentScreenHandler::ShowAuthError(
     const GoogleServiceAuthError& error) {
   switch (error.state()) {
     case GoogleServiceAuthError::NONE:
     case GoogleServiceAuthError::CAPTCHA_REQUIRED:
     case GoogleServiceAuthError::TWO_FACTOR:
@@ skipping 123 matching lines @@
               policy::FormatStoreStatus(status.store_status(),
                                         status.validation_status())),
           true);
       return;
     case policy::EnrollmentStatus::STATUS_STORE_TOKEN_AND_ID_FAILED:
       // This error should not happen for enterprise enrollment.
       ShowError(IDS_ENTERPRISE_ENROLLMENT_STATUS_STORE_TOKEN_AND_ID_FAILED,
                 true);
       NOTREACHED();
       return;
+    case policy::EnrollmentStatus::STATUS_DEVICE_NAMING_FAILED:
+      ShowError(IDS_ENTERPRISE_ENROLLMENT_DEVICE_NAMING_ERROR, false);
+      return;
   }
   NOTREACHED();
 }
 
 // EnrollmentScreenHandler BaseScreenHandler implementation -----
 
 void EnrollmentScreenHandler::Initialize() {
   if (show_on_init_) {
     Show();
     show_on_init_ = false;
   }
 }
 
 void EnrollmentScreenHandler::DeclareLocalizedValues(
     ::login::LocalizedValuesBuilder* builder) {
   builder->Add("oauthEnrollScreenTitle",
                IDS_ENTERPRISE_ENROLLMENT_SCREEN_TITLE);
   builder->Add("oauthEnrollDescription", IDS_ENTERPRISE_ENROLLMENT_DESCRIPTION);
   builder->Add("oauthEnrollReEnrollmentText",
                IDS_ENTERPRISE_ENROLLMENT_RE_ENROLLMENT_TEXT);
   builder->Add("oauthEnrollRetry", IDS_ENTERPRISE_ENROLLMENT_RETRY);
   builder->Add("oauthEnrollCancel", IDS_ENTERPRISE_ENROLLMENT_CANCEL);
   builder->Add("oauthEnrollBack", IDS_ENTERPRISE_ENROLLMENT_BACK);
   builder->Add("oauthEnrollDone", IDS_ENTERPRISE_ENROLLMENT_DONE);
+  builder->Add("oauthEnrollContinue", IDS_ENTERPRISE_ENROLLMENT_CONTINUE);
   builder->Add("oauthEnrollSuccess", IDS_ENTERPRISE_ENROLLMENT_SUCCESS);
+  builder->Add("oauthEnrollNaming", IDS_ENTERPRISE_ENROLLMENT_NAMING);
   builder->Add("oauthEnrollExplainLink",
                IDS_ENTERPRISE_ENROLLMENT_EXPLAIN_LINK);
   builder->Add("oauthEnrollWorking", IDS_ENTERPRISE_ENROLLMENT_WORKING);
+  builder->Add("oauthEnrollAssetIdLabel",
+               IDS_ENTERPRISE_ENROLLMENT_ASSET_ID_LABEL);
+  builder->Add("oauthEnrollLocationLabel",
+               IDS_ENTERPRISE_ENROLLMENT_LOCATION_LABEL);
 }
 
 OobeUI::Screen EnrollmentScreenHandler::GetCurrentScreen() const {
   OobeUI::Screen screen = OobeUI::SCREEN_UNKNOWN;
   OobeUI* oobe_ui = static_cast<OobeUI*>(web_ui()->GetController());
   if (oobe_ui)
     screen = oobe_ui->current_screen();
   return screen;
 }
 
@@ skipping 139 matching lines @@
   frame_error_ = frame_error;
 
   if (network_state_informer_->state() != NetworkStateInformer::ONLINE)
     return;
   if (frame_error_)
     UpdateState(NetworkError::ERROR_REASON_FRAME_ERROR);
   else
     UpdateState(NetworkError::ERROR_REASON_UPDATE);
 }
 
+void EnrollmentScreenHandler::HandleDeviceNaming(const std::string& asset_id,
+                                                 const std::string& location) {
+
+  // TODO: add the device attribute update request
+  // If DeviceAttributeUpdateResponse SUCCESS then status = 0
+  int status = 1;
+  if (status != 0) {
+    // Show DeviceAttributeUpdate error
+    ShowEnrollmentStatus(policy::EnrollmentStatus::ForStatus(
+        policy::EnrollmentStatus::STATUS_DEVICE_NAMING_FAILED));
+  } else {
+    ShowEnrollmentStatus(policy::EnrollmentStatus::ForStatus(
+        policy::EnrollmentStatus::STATUS_SUCCESS));
+  }
+}
+
 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::ShowErrorMessage(const std::string& message,
                                                bool retry) {
@@ skipping 18 matching lines @@
                              : kEnrollmentHelpTopicRegular);
 
   ShowScreen(OobeUI::kScreenOobeEnrollment, &screen_data);
   if (first_show_) {
     first_show_ = false;
     UpdateStateInternal(NetworkError::ERROR_REASON_UPDATE, true);
   }
   histogram_helper_->OnScreenShow();
 }
 
+void EnrollmentScreenHandler::OnBeforeShowNaming(
+    const base::DictionaryValue& data) {
+  CallJS("onBeforeShowNaming", data);
+}
+
 }  // namespace chromeos