Added ConsumerManagementService class to handle enroll state and device owner info in boot lockbox.

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/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
+#include "chrome/browser/chromeos/policy/consumer_management_service.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_switches.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #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);
 
@@ skipping 52 matching lines @@
 
 GaiaContext::GaiaContext()
     : force_reload(false),
       is_local(false),
       password_changed(false),
       show_users(false),
       use_offline(false),
       has_users(false) {}
 
 GaiaScreenHandler::GaiaScreenHandler(
-    const scoped_refptr<NetworkStateInformer>& network_state_informer)
+    const scoped_refptr<NetworkStateInformer>& network_state_informer,
+    policy::ConsumerManagementService* management_service)
     : BaseScreenHandler(kJsScreenPath),
       frame_state_(FRAME_STATE_UNKNOWN),
       frame_error_(net::OK),
       network_state_informer_(network_state_informer),
+      management_service_(management_service),
       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;
+  const bool is_enrolling_consumer_management =
+      context.is_enrolling_consumer_management;
 
   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);
+                    is_enrolling_consumer_management);
 
-  UpdateAuthParams(&params, context.has_users,
-                   context.is_enrolling_consumer_management);
+  UpdateAuthParams(&params,
+                   context.has_users,
+                   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 125 matching lines @@
   Delegate()->SetDisplayEmail(gaia::SanitizeEmail(email));
   UserContext user_context(email);
   user_context.SetKey(Key(password));
   user_context.SetAuthCode(auth_code);
   Delegate()->CompleteLogin(user_context);
 }
 
 void GaiaScreenHandler::HandleCompleteLogin(const std::string& typed_email,
                                             const std::string& password,
                                             bool using_saml) {
-  std::string owner_email = UserManager::Get()->GetOwnerEmail();
-  if (is_enrolling_consumer_management_ && typed_email != owner_email) {
-    // Show Gaia signin page again since we only allow the owner to sign in.
+  if (!is_enrolling_consumer_management_) {
+    DoCompleteLogin(typed_email, password, using_saml);
+    return;
+  }
+
+  // Consumer management enrollment is in progress.
+  const std::string owner_email = UserManager::Get()->GetOwnerEmail();
+  if (typed_email != owner_email) {
+    // Show Gaia sign-in screen again, since we only allow the owner to sign
+    // in.
     populated_email_ = owner_email;
     ShowGaia(is_enrolling_consumer_management_);
     return;
   }
 
-  if (!Delegate())
-    return;
-
-  if (using_saml && !using_saml_api_)
-    RecordSAMLScrapingVerificationResultInHistogram(true);
-
-  const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
-  Delegate()->SetDisplayEmail(sanitized_email);
-  UserContext user_context(sanitized_email);
-  user_context.SetKey(Key(password));
-  user_context.SetAuthFlow(using_saml
-                               ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
-                               : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
-  Delegate()->CompleteLogin(user_context);
-
-  if (test_expects_complete_login_) {
-    VLOG(2) << "Complete test login for " << typed_email
-            << ", requested=" << test_user_;
-
-    test_expects_complete_login_ = false;
-    test_user_.clear();
-    test_pass_.clear();
-  }
+  CHECK(management_service_);
+  management_service_->SetOwner(owner_email,
+                                base::Bind(&GaiaScreenHandler::OnSetOwnerDone,
+                                           weak_factory_.GetWeakPtr(),
+                                           typed_email,
+                                           password,
+                                           using_saml));
 }
 
 void GaiaScreenHandler::HandleUsingSAMLAPI() {
   SetSAMLPrincipalsAPIUsed(true);
 }
 
 void GaiaScreenHandler::HandleScrapedPasswordCount(int password_count) {
   SetSAMLPrincipalsAPIUsed(false);
   // Use a histogram that has 11 buckets, one for each of the values in [0, 9]
   // and an overflow bucket at the end.
@@ skipping 36 matching lines @@
     // focus to current pod (see crbug/175243).
     DCHECK(signin_screen_handler_);
     signin_screen_handler_->RefocusCurrentPod();
   }
   HandleFrameLoadingCompleted(0);
 
   if (test_expects_complete_login_)
     SubmitLoginFormForTest();
 }
 
+void GaiaScreenHandler::OnSetOwnerDone(const std::string& typed_email,
+                                       const std::string& password,
+                                       bool using_saml,
+                                       bool success) {
+  if (!success) {
+    LOG(ERROR) << "Failed to write owner e-mail to boot lockbox.";
+    CHECK(management_service_);
+    management_service_->SetEnrollmentState(
+        policy::ConsumerManagementService::ENROLLMENT_BOOT_LOCKBOX_FAILED);
+  }
+  DoCompleteLogin(typed_email, password, using_saml);
+}
+
+void GaiaScreenHandler::DoCompleteLogin(const std::string& typed_email,
+                                        const std::string& password,
+                                        bool using_saml) {
+  if (!Delegate())
+    return;
+
+  if (using_saml && !using_saml_api_)
+    RecordSAMLScrapingVerificationResultInHistogram(true);
+
+  const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
+  Delegate()->SetDisplayEmail(sanitized_email);
+  UserContext user_context(sanitized_email);
+  user_context.SetKey(Key(password));
+  user_context.SetAuthFlow(using_saml
+                               ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
+                               : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
+  Delegate()->CompleteLogin(user_context);
+
+  if (test_expects_complete_login_) {
+    VLOG(2) << "Complete test login for " << typed_email
+            << ", requested=" << test_user_;
+
+    test_expects_complete_login_ = false;
+    test_user_.clear();
+    test_pass_.clear();
+  }
+}
+
 void GaiaScreenHandler::PopulateEmail(const std::string& user_id) {
   populated_email_ = user_id;
 }
 
 void GaiaScreenHandler::PasswordChangedFor(const std::string& user_id) {
   password_changed_for_.insert(user_id);
 }
 
 void GaiaScreenHandler::StartClearingDnsCache() {
   if (dns_clear_task_running_ || !g_browser_process->io_thread())
@@ skipping 172 matching lines @@
 
 SigninScreenHandlerDelegate* GaiaScreenHandler::Delegate() {
   DCHECK(signin_screen_handler_);
   return signin_screen_handler_->delegate_;
 }
 
 void GaiaScreenHandler::SetSigninScreenHandler(SigninScreenHandler* handler) {
   signin_screen_handler_ = handler;
 }
 }  // namespace chromeos