ChromeOS cryptohome should be able to use gaia id as user identifier.

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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_cryptohome_client.h"
+#include "components/signin/core/account_id/account_id.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Invoke;
 using testing::WithArg;
 
 namespace cryptohome {
 
 namespace {
@@ skipping 83 matching lines @@
     MountError return_code,
     const std::vector<KeyDefinition>& key_definitions) {
   success_ = success;
   return_code_ = return_code;
   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);
+  expected_id.set_account_id(
+      cryptohome::Identification(AccountId::FromUserEmail(kUserID)).id());

[xiyuan, 2016/02/17 23:14:26]

nit: remove "cryptohome::" since it is already in namespace cryptohome.

[Alexander Alekseev, 2016/02/18 13:45:14]

Done.

   const cryptohome::AuthorizationRequest expected_auth;
   cryptohome::GetKeyDataRequest expected_request;
       expected_request.mutable_key()->mutable_data()->set_label(kKeyLabel);
 
   EXPECT_CALL(*cryptohome_client_,
               GetKeyDataEx(EqualsProto(expected_id),
                            EqualsProto(expected_auth),
                            EqualsProto(expected_request),
                            _))
       .Times(1)
@@ skipping 14 matching lines @@
   KeyProviderData* data = key_data->mutable_provider_data();
   KeyProviderData::Entry* entry = data->add_entry();
   entry->set_name(kProviderData1Name);
   entry->set_number(kProviderData1Number);
   entry = data->add_entry();
   entry->set_name(kProviderData2Name);
   entry->set_bytes(kProviderData2Bytes);
 
   // Call GetKeyDataEx().
   HomedirMethods::GetInstance()->GetKeyDataEx(
-    Identification(kUserID),
-    kKeyLabel,
-    base::Bind(&HomedirMethodsTest::StoreGetKeyDataExResult,
-               base::Unretained(this)));
+      Identification(AccountId::FromUserEmail(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_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,
             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 = &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