Add a basic demo mode browser test.

chrome/browser/chromeos/login/parallel_authenticator.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/parallel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 92 matching lines @@
 void MountGuest(AuthAttemptState* attempt,
                 scoped_refptr<ParallelAuthenticator> resolver) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncMountGuest(
       base::Bind(&TriggerResolveWithLoginTimeMarker,
                  "CryptohomeMount-End",
                  attempt,
                  resolver));
 }
 
+// Calls cryptohome's mount method for guest and also get the user hash from
+// cryptohome.
+void MountGuestAndGetHash(AuthAttemptState* attempt,
+                          scoped_refptr<ParallelAuthenticator> resolver) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  cryptohome::AsyncMethodCaller::GetInstance()->AsyncMountGuest(

[bartfab (slow), 2014/03/27 14:13:29]

The AuthAttemptState constructor sets username_hash_obtained_ = true, meaning
that the user id hash is already known and there is no need to wait for it.
Since you want to retrieve the hash from cryptohome, you need to make sure that
ParallelAuthenticator waits for the result by invoking
attempt->UsernameHashRequested(); before making any cryptohome calls.

See line 85, where Mount() does exactly that.

[rkc, 2014/03/27 21:43:10]

Done.

+      base::Bind(&TriggerResolveWithLoginTimeMarker,
+                 "CryptohomeMount-End",
+                 attempt,
+                 resolver));
+  cryptohome::AsyncMethodCaller::GetInstance()->AsyncGetSanitizedUsername(
+      attempt->user_context.username,
+      base::Bind(&TriggerResolveHash,
+                 attempt,
+                 resolver));
+}
+
 // Calls cryptohome's MountPublic method
 void MountPublic(AuthAttemptState* attempt,
                  scoped_refptr<ParallelAuthenticator> resolver,
                  int flags) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncMountPublic(
       attempt->user_context.username,
       flags,
       base::Bind(&TriggerResolveWithLoginTimeMarker,
                  "CryptohomeMountPublic-End",
@@ skipping 216 matching lines @@
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&Mount,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this),
                  cryptohome::CREATE_IF_MISSING | cryptohome::ENSURE_EPHEMERAL));
 }
 
 void ParallelAuthenticator::LoginAsKioskAccount(
-    const std::string& app_user_id, bool force_ephemeral) {
+    const std::string& app_user_id,
+    bool use_guest_mount) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  std::string user_id =
-      force_ephemeral ? UserManager::kGuestUserName : app_user_id;
+  const std::string user_id =
+      use_guest_mount ? UserManager::kGuestUserName : app_user_id;
   current_state_.reset(new AuthAttemptState(
       UserContext(user_id,
                   std::string(),  // password
                   std::string()),  // auth_code
       std::string(),  // login_token
       std::string(),  // login_captcha
       User::USER_TYPE_KIOSK_APP,
       false));
 
   remove_user_data_on_failure_ = true;
-  if (!force_ephemeral) {
+  if (!use_guest_mount) {
     MountPublic(current_state_.get(),
           scoped_refptr<ParallelAuthenticator>(this),
           cryptohome::CREATE_IF_MISSING);
   } else {
     ephemeral_mount_attempted_ = true;
-    MountGuest(current_state_.get(),
-               scoped_refptr<ParallelAuthenticator>(this));
+    MountGuestAndGetHash(current_state_.get(),
+                         scoped_refptr<ParallelAuthenticator>(this));
   }
 }
 
 void ParallelAuthenticator::OnRetailModeLoginSuccess() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Retail mode login success";
   // Send notification of success
   AuthenticationNotificationDetails details(true);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_AUTHENTICATION,
@@ skipping 434 matching lines @@
   Resolve();
 }
 
 void ParallelAuthenticator::SetOwnerState(bool owner_check_finished,
                                           bool check_result) {
   owner_is_verified_ = owner_check_finished;
   user_can_login_ = check_result;
 }
 
 }  // namespace chromeos