Switch CryptohomeAuthenticator from MountAsync() to MountEx()

chrome/browser/chromeos/login/auth/cryptohome_authenticator_unittest.cc

 // Copyright 2014 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/auth/chrome_cryptohome_authenticator.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/chromeos/settings/mock_owner_key_util.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/cryptohome/cryptohome_parameters.h"
+#include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
+#include "chromeos/cryptohome/mock_homedir_methods.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
+#include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/mock_auth_status_consumer.h"
 #include "chromeos/login/auth/mock_url_fetchers.h"
 #include "chromeos/login/auth/test_attempt_state.h"
 #include "chromeos/login/auth/user_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_test_nss_chromeos_user.h"
@@ skipping 70 matching lines @@
 
 }  // namespace
 
 class CryptohomeAuthenticatorTest : public testing::Test {
  public:
   CryptohomeAuthenticatorTest()
       : user_context_("me@nowhere.org"),
         user_manager_(new FakeUserManager()),
         user_manager_enabler_(user_manager_),
         mock_caller_(NULL),
+        mock_homedir_methods_(NULL),
         owner_key_util_(new MockOwnerKeyUtil) {
     user_context_.SetKey(Key("fakepass"));
     user_context_.SetUserIDHash("me_nowhere_com_hash");
     const user_manager::User* user =
         user_manager_->AddUser(user_context_.GetUserID());
     profile_.set_profile_name(user_context_.GetUserID());
 
     ProfileHelper::Get()->SetUserToProfileMappingForTesting(user, &profile_);
 
     transformed_key_ = *user_context_.GetKey();
     transformed_key_.Transform(Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
                                SystemSaltGetter::ConvertRawSaltToHexString(
                                    FakeCryptohomeClient::GetStubSystemSalt()));
   }
 
   virtual ~CryptohomeAuthenticatorTest() {}
 
   virtual void SetUp() {
     CommandLine::ForCurrentProcess()->AppendSwitch(switches::kLoginManager);
 
     mock_caller_ = new cryptohome::MockAsyncMethodCaller;
     cryptohome::AsyncMethodCaller::InitializeForTesting(mock_caller_);
+    mock_homedir_methods_ = new cryptohome::MockHomedirMethods;
+    mock_homedir_methods_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+    cryptohome::HomedirMethods::InitializeForTesting(mock_homedir_methods_);
 
     fake_cryptohome_client_ = new FakeCryptohomeClient;
     chromeos::DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
         scoped_ptr<CryptohomeClient>(fake_cryptohome_client_));
 
     SystemSaltGetter::Initialize();
 
     OwnerSettingsService::SetOwnerKeyUtilForTesting(owner_key_util_);
 
     auth_ = new ChromeCryptohomeAuthenticator(&consumer_);
     state_.reset(new TestAttemptState(user_context_, false));
   }
 
   // Tears down the test fixture.
   virtual void TearDown() {
     OwnerSettingsService::SetOwnerKeyUtilForTesting(NULL);
     SystemSaltGetter::Shutdown();
     DBusThreadManager::Shutdown();
 
     cryptohome::AsyncMethodCaller::Shutdown();
     mock_caller_ = NULL;
+    cryptohome::HomedirMethods::Shutdown();
+    mock_homedir_methods_ = NULL;
   }
 
   base::FilePath PopulateTempFile(const char* data, int data_len) {
     base::FilePath out;
     FILE* tmp_file = base::CreateAndOpenTemporaryFile(&out);
     EXPECT_NE(tmp_file, static_cast<FILE*>(NULL));
     EXPECT_EQ(base::WriteFile(out, data, data_len), data_len);
     EXPECT_TRUE(base::CloseFile(tmp_file));
     return out;
   }
@@ skipping 83 matching lines @@
 
   ScopedDeviceSettingsTestHelper device_settings_test_helper_;
   ScopedTestCrosSettings test_cros_settings_;
 
   TestingProfile profile_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   FakeUserManager* user_manager_;
   ScopedUserManagerEnabler user_manager_enabler_;
 
   cryptohome::MockAsyncMethodCaller* mock_caller_;
+  cryptohome::MockHomedirMethods* mock_homedir_methods_;
 
   MockAuthStatusConsumer consumer_;
 
   scoped_refptr<CryptohomeAuthenticator> auth_;
   scoped_ptr<TestAttemptState> state_;
   FakeCryptohomeClient* fake_cryptohome_client_;
 
   scoped_refptr<MockOwnerKeyUtil> owner_key_util_;
 };
 
@@ skipping 245 matching lines @@
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataResync) {
   UserContext expected_user_context(user_context_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a cryptohome
-  // remove attempt and a cryptohome create attempt (indicated by the
-  // |CREATE_IF_MISSING| flag to AsyncMount).
+  // remove attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncRemove(user_context_.GetUserID(), _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_caller_,
-              AsyncMount(user_context_.GetUserID(),
-                         transformed_key_.GetSecret(),
-                         cryptohome::CREATE_IF_MISSING,
-                         _))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*mock_caller_,
-              AsyncGetSanitizedUsername(user_context_.GetUserID(), _))
-      .Times(1)
-      .RetiresOnSaturation();
+
+  // Set up mock homedir methods to respond successfully to a cryptohome create
+  // attempt.
+  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
+                                           std::string(),
+                                           cryptohome::PRIV_DEFAULT);
+  cryptohome::MountParameters mount(false /* ephemeral */);
+  mount.create_keys.push_back(cryptohome::KeyDefinition(
+      transformed_key_.GetSecret(),
+      "gaia",
+      cryptohome::PRIV_DEFAULT));
+  EXPECT_CALL(*mock_homedir_methods_,
+              MountEx(cryptohome::Identification(user_context_.GetUserID()),
+                      cryptohome::Authorization(auth_key),
+                      mount,
+                      _))
+      .Times(1);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveResyncFail) {
   FailOnLoginSuccess();
@@ skipping 30 matching lines @@
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a key migration.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(
       *mock_caller_,
       AsyncMigrateKey(
           user_context_.GetUserID(), _, transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_caller_,
-              AsyncMount(user_context_.GetUserID(),
-                         transformed_key_.GetSecret(),
-                         cryptohome::MOUNT_FLAGS_NONE,
-                         _))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*mock_caller_,
-              AsyncGetSanitizedUsername(user_context_.GetUserID(), _))
-      .Times(1)
-      .RetiresOnSaturation();
+
+  // Set up mock homedir methods to respond successfully to a cryptohome mount
+  // attempt.
+  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
+                                           std::string(),
+                                           cryptohome::PRIV_DEFAULT);
+  EXPECT_CALL(*mock_homedir_methods_,
+              MountEx(cryptohome::Identification(user_context_.GetUserID()),
+                      cryptohome::Authorization(auth_key),
+                      cryptohome::MountParameters(false /* ephemeral */),
+                      _));
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecoverButFail) {
   FailOnLoginSuccess();
@@ skipping 39 matching lines @@
             SetAndResolveState(auth_.get(), state_.release()));
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveCreateForNewUser) {
   UserContext expected_user_context(user_context_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
-  // Set up mock async method caller to respond successfully to a cryptohome
-  // create attempt (indicated by the |CREATE_IF_MISSING| flag to AsyncMount).
-  mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
-  EXPECT_CALL(*mock_caller_,
-              AsyncMount(user_context_.GetUserID(),
-                         transformed_key_.GetSecret(),
-                         cryptohome::CREATE_IF_MISSING,
-                         _))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*mock_caller_,
-              AsyncGetSanitizedUsername(user_context_.GetUserID(), _))
-      .Times(1)
-      .RetiresOnSaturation();
+  // Set up mock homedir methods to respond successfully to a cryptohome create
+  // attempt.
+  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
+                                           std::string(),
+                                           cryptohome::PRIV_DEFAULT);
+  cryptohome::MountParameters mount(false /* ephemeral */);
+  mount.create_keys.push_back(cryptohome::KeyDefinition(
+      transformed_key_.GetSecret(),
+      "gaia",
+      cryptohome::PRIV_DEFAULT));
+  EXPECT_CALL(*mock_homedir_methods_,
+              MountEx(cryptohome::Identification(user_context_.GetUserID()),
+                      cryptohome::Authorization(auth_key),
+                      mount,
+                      _));
 
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected because the user doesn't exist; additionally,
   // an online auth attempt has completed successfully.
   state_->PresetCryptohomeStatus(false,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
@@ skipping 33 matching lines @@
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncCheckKey(user_context_.GetUserID(), _, _))
       .Times(1)
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(user_context_);
   base::MessageLoop::current()->Run();
 }
 
 }  // namespace chromeos