Merge cryptohome::RetrievedKeyData with cryptohome::KeyDefinition

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 <vector>
 
 #include "base/basictypes.h"
 #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/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_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"
@@ skipping 226 matching lines @@
   }
 
   void ExpectPasswordChange() {
     EXPECT_CALL(consumer_, OnPasswordChangeDetected())
         .WillOnce(Invoke(MockAuthStatusConsumer::OnMigrateQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectGetKeyDataExCall(scoped_ptr<int64> key_type,
                               scoped_ptr<std::string> salt) {
-    key_data_.clear();
-    key_data_.push_back(new cryptohome::RetrievedKeyData(
-       cryptohome::RetrievedKeyData::TYPE_PASSWORD,
-       kCryptohomeGAIAKeyLabel,
-       1));
-    key_data_.front()->privileges = cryptohome::PRIV_DEFAULT;
-    key_data_.front()->authorization_types.push_back(
-        cryptohome::RetrievedKeyData::AUTHORIZATION_TYPE_HMACSHA256);
+    key_definitions_.clear();
+    key_definitions_.push_back(cryptohome::KeyDefinition(
+        std::string() /* secret */,
+        kCryptohomeGAIAKeyLabel,
+        cryptohome::PRIV_DEFAULT));
+    cryptohome::KeyDefinition& key_definition = key_definitions_.back();
+    key_definition.revision = 1;
     if (key_type) {
-      scoped_ptr<cryptohome::RetrievedKeyData::ProviderData> provider_data(
-          new cryptohome::RetrievedKeyData::ProviderData("type"));
-      provider_data->number = key_type.Pass();
-      key_data_.front()->provider_data.push_back(provider_data.release());
+      key_definition.provider_data.push_back(
+          cryptohome::KeyDefinition::ProviderData("type"));
+      key_definition.provider_data.back().number = key_type.Pass();
     }
     if (salt) {
-      scoped_ptr<cryptohome::RetrievedKeyData::ProviderData> provider_data(
-          new cryptohome::RetrievedKeyData::ProviderData("salt"));
-      provider_data->bytes = salt.Pass();
-      key_data_.front()->provider_data.push_back(provider_data.release());
+      key_definition.provider_data.push_back(
+          cryptohome::KeyDefinition::ProviderData("salt"));
+      key_definition.provider_data.back().bytes = salt.Pass();
     }
     EXPECT_CALL(*mock_homedir_methods_, GetKeyDataEx(
         cryptohome::Identification(user_context_.GetUserID()),
         kCryptohomeGAIAKeyLabel,
         _))
         .WillOnce(WithArg<2>(Invoke(
             this,
             &CryptohomeAuthenticatorTest::InvokeGetDataExCallback)));
   }
 
@@ skipping 36 matching lines @@
   void SetOwnerState(bool owner_check_finished, bool check_result) {
     auth_->SetOwnerState(owner_check_finished, check_result);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   UserContext user_context_;
   UserContext user_context_with_transformed_key_;
   Key transformed_key_;
 
-  ScopedVector<cryptohome::RetrievedKeyData> key_data_;
+  std::vector<cryptohome::KeyDefinition> key_definitions_;
 
   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<ownership::MockOwnerKeyUtil> owner_key_util_;
 
  private:
   void InvokeGetDataExCallback(
       const cryptohome::HomedirMethods::GetKeyDataCallback& callback) {
     callback.Run(true /* success */,
                  cryptohome::MOUNT_ERROR_NONE,
-                 key_data_.Pass());
+                 key_definitions_);
   }
 };
 
 TEST_F(CryptohomeAuthenticatorTest, OnAuthSuccess) {
   EXPECT_CALL(consumer_, OnAuthSuccess(user_context_))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_.get(), state_.release());
   auth_->OnAuthSuccess();
@@ skipping 458 matching lines @@
   // salt.
   ExpectGetKeyDataExCall(
       make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
       scoped_ptr<std::string>());
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 }  // namespace chromeos