Consumer management enrollment signin screen change:

chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

 // Copyright 2013 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/gaia_screen_handler.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 18 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 const char kJsScreenPath[] = "login.GaiaSigninScreen";
 
-void UpdateAuthParams(base::DictionaryValue* params, bool has_users) {
+void UpdateAuthParams(base::DictionaryValue* params, bool has_users,
+                      bool is_enrolling_consumer_management) {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = true;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   bool allow_guest = true;
   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
   // Account creation depends on Guest sign-in (http://crosbug.com/24570).
   params->SetBoolean("createAccount", allow_new_user && allow_guest);
   params->SetBoolean("guestSignin", allow_guest);
 
   // Allow supervised user creation only if:
@@ skipping 16 matching lines @@
 
   params->SetBoolean("managedUsersEnabled", supervised_users_allowed);
   params->SetBoolean("managedUsersCanCreate", supervised_users_can_create);
   if (!supervised_users_can_create) {
     params->SetString("managedUsersRestrictionReason",
                       l10n_util::GetStringUTF16(message_id));
   }
 
   // Now check whether we're in multi-profiles user adding scenario and
   // disable GAIA right panel features if that's the case.
-  if (UserAddingScreen::Get()->IsRunning()) {
+  // For consumer management enrollment, we also hide all right panel components
+  // and show only an enrollment message.
+  if (UserAddingScreen::Get()->IsRunning() ||
+      is_enrolling_consumer_management) {
     params->SetBoolean("createAccount", false);
     params->SetBoolean("guestSignin", false);
     params->SetBoolean("managedUsersEnabled", false);
   }
 }
 
 void RecordSAMLScrapingVerificationResultInHistogram(bool success) {
   UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.Scraping.VerificationResult", success);
 }
 
@@ skipping 22 matching lines @@
     : BaseScreenHandler(kJsScreenPath),
       frame_state_(FRAME_STATE_UNKNOWN),
       frame_error_(net::OK),
       network_state_informer_(network_state_informer),
       dns_cleared_(false),
       dns_clear_task_running_(false),
       cookies_cleared_(false),
       focus_stolen_(false),
       gaia_silent_load_(false),
       using_saml_api_(false),
+      is_enrolling_consumer_management_(false),
       test_expects_complete_login_(false),
       signin_screen_handler_(NULL),
       weak_factory_(this) {
   DCHECK(network_state_informer_.get());
 }
 
 GaiaScreenHandler::~GaiaScreenHandler() {
 }
 
 void GaiaScreenHandler::LoadGaia(const GaiaContext& context) {
   base::DictionaryValue params;
 
   params.SetBoolean("forceReload", context.force_reload);
   params.SetBoolean("isLocal", context.is_local);
   params.SetBoolean("passwordChanged", context.password_changed);
   params.SetBoolean("isShowUsers", context.show_users);
   params.SetBoolean("useOffline", context.use_offline);
   params.SetString("email", context.email);
+  params.SetBoolean("isEnrollingConsumerManagement",
+                    context.is_enrolling_consumer_management);
 
-  UpdateAuthParams(&params, context.has_users);
+  UpdateAuthParams(&params, context.has_users,
+                   context.is_enrolling_consumer_management);
 
   if (!context.use_offline) {
     const std::string app_locale = g_browser_process->GetApplicationLocale();
     if (!app_locale.empty())
       params.SetString("hl", app_locale);
   } else {
     base::DictionaryValue* localized_strings = new base::DictionaryValue();
     localized_strings->SetString(
         "stringEmail", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMAIL));
     localized_strings->SetString(
@@ skipping 22 matching lines @@
 
   if (command_line->HasSwitch(chromeos::switches::kEnableEmbeddedSignin))
     params.SetBoolean("useEmbedded", true);
 
   frame_state_ = FRAME_STATE_LOADING;
   CallJS("loadAuthExtension", params);
 }
 
 void GaiaScreenHandler::UpdateGaia(const GaiaContext& context) {
   base::DictionaryValue params;
-  UpdateAuthParams(&params, context.has_users);
+  UpdateAuthParams(&params, context.has_users,
+                   context.is_enrolling_consumer_management);
   CallJS("updateAuthExtension", params);
 }
 
 void GaiaScreenHandler::ReloadGaia(bool force_reload) {
   if (frame_state_ == FRAME_STATE_LOADING && !force_reload) {
     VLOG(1) << "Skipping reloading of Gaia since gaia is loading.";
     return;
   }
   NetworkStateInformer::State state = network_state_informer_->state();
   if (state != NetworkStateInformer::ONLINE) {
@@ skipping 10 matching lines @@
     LocalizedValuesBuilder* builder) {
   builder->Add("signinScreenTitle", IDS_SIGNIN_SCREEN_TITLE);
   builder->Add("signinScreenPasswordChanged",
                IDS_SIGNIN_SCREEN_PASSWORD_CHANGED);
   builder->Add("createAccount", IDS_CREATE_ACCOUNT_HTML);
   builder->Add("guestSignin", IDS_BROWSE_WITHOUT_SIGNING_IN_HTML);
   builder->Add("createLocallyManagedUser",
                IDS_CREATE_LOCALLY_MANAGED_USER_HTML);
   builder->Add("createManagedUserFeatureName",
                IDS_CREATE_LOCALLY_MANAGED_USER_FEATURE_NAME);
+  builder->Add("consumerManagementEnrollmentSigninMessage",
+               IDS_LOGIN_CONSUMER_MANAGEMENT_ENROLLMENT);
 
   // Strings used by the SAML fatal error dialog.
   builder->Add("fatalErrorMessageNoEmail", IDS_LOGIN_FATAL_ERROR_NO_EMAIL);
   builder->Add("fatalErrorMessageNoPassword",
                IDS_LOGIN_FATAL_ERROR_NO_PASSWORD);
   builder->Add("fatalErrorMessageVerificationFailed",
                IDS_LOGIN_FATAL_ERROR_PASSWORD_VERIFICATION);
   builder->Add("fatalErrorMessageInsecureURL",
                IDS_LOGIN_FATAL_ERROR_TEXT_INSECURE_URL);
   builder->Add("fatalErrorInstructions", IDS_LOGIN_FATAL_ERROR_INSTRUCTIONS);
@@ skipping 217 matching lines @@
   // Test properties are cleared in HandleCompleteLogin because the form
   // submission might fail and login will not be attempted after reloading
   // if they are cleared here.
 }
 
 void GaiaScreenHandler::SetSAMLPrincipalsAPIUsed(bool api_used) {
   using_saml_api_ = api_used;
   UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.APIUsed", api_used);
 }
 
-void GaiaScreenHandler::ShowGaia() {
+void GaiaScreenHandler::ShowGaia(bool is_enrolling_consumer_management) {
+  is_enrolling_consumer_management_ = is_enrolling_consumer_management;
   if (gaia_silent_load_ && populated_email_.empty()) {
     dns_cleared_ = true;
     cookies_cleared_ = true;
     ShowGaiaScreenIfReady();
   } else {
     StartClearingDnsCache();
     StartClearingCookies(base::Bind(&GaiaScreenHandler::ShowGaiaScreenIfReady,
                                     weak_factory_.GetWeakPtr()));
   }
 }
@@ skipping 56 matching lines @@
 void GaiaScreenHandler::LoadAuthExtension(bool force,
                                           bool silent_load,
                                           bool offline) {
   GaiaContext context;
   context.force_reload = force;
   context.is_local = offline;
   context.password_changed = !populated_email_.empty() &&
                              password_changed_for_.count(populated_email_);
   context.use_offline = offline;
   context.email = populated_email_;
+  context.is_enrolling_consumer_management = is_enrolling_consumer_management_;
   if (Delegate()) {
     context.show_users = Delegate()->IsShowUsers();
     context.has_users = !Delegate()->GetUsers().empty();
   }
 
   populated_email_.clear();
 
   LoadGaia(context);
 }
 
 void GaiaScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
   if (signin_screen_handler_)
     signin_screen_handler_->UpdateState(reason);
 }
 
 SigninScreenHandlerDelegate* GaiaScreenHandler::Delegate() {
   DCHECK(signin_screen_handler_);
   return signin_screen_handler_->delegate_;
 }
 
 void GaiaScreenHandler::SetSigninScreenHandler(SigninScreenHandler* handler) {
   signin_screen_handler_ = handler;
 }
 }  // namespace chromeos