Merge cryptohome::RetrievedKeyData with cryptohome::KeyDefinition

chromeos/cryptohome/homedir_methods_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 "chromeos/cryptohome/homedir_methods.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 37 matching lines @@
   HomedirMethodsTest();
   virtual ~HomedirMethodsTest();
 
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void RunProtobufMethodCallback(
       const chromeos::CryptohomeClient::ProtobufMethodCallback& callback);
 
-  void StoreGetKeyDataExResult(bool success,
-                               MountError return_code,
-                               ScopedVector<RetrievedKeyData> key_data);
+  void StoreGetKeyDataExResult(
+      bool success,
+      MountError return_code,
+      const std::vector<KeyDefinition>& key_definitions);
 
  protected:
   chromeos::MockCryptohomeClient* cryptohome_client_;
 
   // The reply that |cryptohome_client_| will make.
   cryptohome::BaseReply cryptohome_reply_;
 
   // The results of the most recent |HomedirMethods| method call.
   bool success_;
   MountError return_code_;
-  ScopedVector<RetrievedKeyData> key_data_;
+  std::vector<KeyDefinition> key_definitions_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HomedirMethodsTest);
 };
 
 HomedirMethodsTest::HomedirMethodsTest() : cryptohome_client_(NULL),
                                            success_(false),
                                            return_code_(MOUNT_ERROR_FATAL) {
 }
 
@@ skipping 17 matching lines @@
 void HomedirMethodsTest::RunProtobufMethodCallback(
     const chromeos::CryptohomeClient::ProtobufMethodCallback& callback) {
   callback.Run(chromeos::DBUS_METHOD_CALL_SUCCESS,
                true,
                cryptohome_reply_);
 }
 
 void HomedirMethodsTest::StoreGetKeyDataExResult(
     bool success,
     MountError return_code,
-    ScopedVector<RetrievedKeyData> key_data) {
+    const std::vector<KeyDefinition>& key_definitions) {
   success_ = success;
   return_code_ = return_code;
-  key_data_.swap(key_data);
+  key_definitions_ = key_definitions;
 }
 
 // Verifies that the result of a GetKeyDataEx() call is correctly parsed.
 TEST_F(HomedirMethodsTest, GetKeyDataEx) {
   AccountIdentifier expected_id;
   expected_id.set_email(kUserID);
   const cryptohome::AuthorizationRequest expected_auth;
   cryptohome::GetKeyDataRequest expected_request;
       expected_request.mutable_key()->mutable_data()->set_label(kKeyLabel);
 
@@ skipping 28 matching lines @@
   // Call GetKeyDataEx().
   HomedirMethods::GetInstance()->GetKeyDataEx(
     Identification(kUserID),
     kKeyLabel,
     base::Bind(&HomedirMethodsTest::StoreGetKeyDataExResult,
                base::Unretained(this)));
 
   // Verify that the call was successful and the result was correctly parsed.
   EXPECT_TRUE(success_);
   EXPECT_EQ(MOUNT_ERROR_NONE, return_code_);
-  ASSERT_EQ(1u, key_data_.size());
-  const RetrievedKeyData* retrieved_key_data = key_data_.front();
-  EXPECT_EQ(RetrievedKeyData::TYPE_PASSWORD, retrieved_key_data->type);
+  ASSERT_EQ(1u, key_definitions_.size());
+  const KeyDefinition& key_definition = key_definitions_.front();
+  EXPECT_EQ(KeyDefinition::TYPE_PASSWORD, key_definition.type);
   EXPECT_EQ(PRIV_MOUNT | PRIV_ADD | PRIV_REMOVE,
-            retrieved_key_data->privileges);
-  EXPECT_EQ(kKeyRevision, retrieved_key_data->revision);
-  ASSERT_EQ(1u, retrieved_key_data->authorization_types.size());
-  EXPECT_EQ(RetrievedKeyData::AUTHORIZATION_TYPE_HMACSHA256,
-            retrieved_key_data->authorization_types.front());
-  ASSERT_EQ(2u, retrieved_key_data->provider_data.size());
-  const RetrievedKeyData::ProviderData* provider_data =
-      retrieved_key_data->provider_data[0];
+            key_definition.privileges);
+  EXPECT_EQ(kKeyRevision, key_definition.revision);
+  ASSERT_EQ(1u, key_definition.authorization_data.size());
+  EXPECT_EQ(KeyDefinition::AuthorizationData::TYPE_HMACSHA256,
+            key_definition.authorization_data.front().type);
+  ASSERT_EQ(2u, key_definition.provider_data.size());
+  const KeyDefinition::ProviderData* provider_data =
+      &key_definition.provider_data[0];
   EXPECT_EQ(kProviderData1Name, provider_data->name);
   ASSERT_TRUE(provider_data->number);
   EXPECT_EQ(kProviderData1Number, *provider_data->number.get());
   EXPECT_FALSE(provider_data->bytes);
-  provider_data = retrieved_key_data->provider_data[1];
+  provider_data = &key_definition.provider_data[1];
   EXPECT_EQ(kProviderData2Name, provider_data->name);
   EXPECT_FALSE(provider_data->number);
   ASSERT_TRUE(provider_data->bytes);
   EXPECT_EQ(kProviderData2Bytes, *provider_data->bytes.get());
 }
 
 }  // namespace cryptohome