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

chromeos/cryptohome/homedir_methods.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
     KeyProviderData::Entry* entry =
         data->mutable_provider_data()->add_entry();
     entry->set_name(it->name);
     if (it->number)
       entry->set_number(*it->number);
     if (it->bytes)
       entry->set_bytes(*it->bytes);
   }
 }
 
-// Fill identification protobuffer.
-void FillIdentificationProtobuf(const Identification& id,
-                                cryptohome::AccountIdentifier* id_proto) {
-  id_proto->set_email(id.user_id);
-}
-
 // Fill authorization protobuffer.
 void FillAuthorizationProtobuf(const Authorization& auth,
                                cryptohome::AuthorizationRequest* auth_proto) {
   Key* key = auth_proto->mutable_key();
   if (!auth.label.empty()) {
     key->mutable_data()->set_label(auth.label);
   }
   key->set_secret(auth.key);
 }
 
@@ skipping 62 matching lines @@
 // The implementation of HomedirMethods
 class HomedirMethodsImpl : public HomedirMethods {
  public:
   HomedirMethodsImpl() : weak_ptr_factory_(this) {}
 
   ~HomedirMethodsImpl() override {}
 
   void GetKeyDataEx(const Identification& id,
                     const std::string& label,
                     const GetKeyDataCallback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest kEmptyAuthProto;
     cryptohome::GetKeyDataRequest request;
 
-    FillIdentificationProtobuf(id, &id_proto);
     request.mutable_key()->mutable_data()->set_label(label);
 
     DBusThreadManager::Get()->GetCryptohomeClient()->GetKeyDataEx(
-        id_proto,
-        kEmptyAuthProto,
-        request,
+        id, kEmptyAuthProto, request,
         base::Bind(&HomedirMethodsImpl::OnGetKeyDataExCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void CheckKeyEx(const Identification& id,
                   const Authorization& auth,
                   const Callback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest auth_proto;
     cryptohome::CheckKeyRequest request;
 
-    FillIdentificationProtobuf(id, &id_proto);
     FillAuthorizationProtobuf(auth, &auth_proto);
 
     DBusThreadManager::Get()->GetCryptohomeClient()->CheckKeyEx(
-        id_proto,
-        auth_proto,
-        request,
+        id, auth_proto, request,
         base::Bind(&HomedirMethodsImpl::OnBaseReplyCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void MountEx(const Identification& id,
                const Authorization& auth,
                const MountParameters& request,
                const MountCallback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest auth_proto;
     cryptohome::MountRequest request_proto;
 
-    FillIdentificationProtobuf(id, &id_proto);
     FillAuthorizationProtobuf(auth, &auth_proto);
 
     if (request.ephemeral)
       request_proto.set_require_ephemeral(true);
 
     if (!request.create_keys.empty()) {
       CreateRequest* create = request_proto.mutable_create();
       for (size_t i = 0; i < request.create_keys.size(); ++i)
         FillKeyProtobuf(request.create_keys[i], create->add_keys());
     }
 
     DBusThreadManager::Get()->GetCryptohomeClient()->MountEx(
-        id_proto,
-        auth_proto,
-        request_proto,
+        id, auth_proto, request_proto,
         base::Bind(&HomedirMethodsImpl::OnMountExCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void AddKeyEx(const Identification& id,
                 const Authorization& auth,
                 const KeyDefinition& new_key,
                 bool clobber_if_exists,
                 const Callback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest auth_proto;
     cryptohome::AddKeyRequest request;
 
-    FillIdentificationProtobuf(id, &id_proto);
     FillAuthorizationProtobuf(auth, &auth_proto);
     FillKeyProtobuf(new_key, request.mutable_key());
     request.set_clobber_if_exists(clobber_if_exists);
 
     DBusThreadManager::Get()->GetCryptohomeClient()->AddKeyEx(
-        id_proto,
-        auth_proto,
-        request,
+        id, auth_proto, request,
         base::Bind(&HomedirMethodsImpl::OnBaseReplyCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void RemoveKeyEx(const Identification& id,
                    const Authorization& auth,
                    const std::string& label,
                    const Callback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest auth_proto;
     cryptohome::RemoveKeyRequest request;
 
-    FillIdentificationProtobuf(id, &id_proto);
     FillAuthorizationProtobuf(auth, &auth_proto);
     request.mutable_key()->mutable_data()->set_label(label);
 
     DBusThreadManager::Get()->GetCryptohomeClient()->RemoveKeyEx(
-        id_proto,
-        auth_proto,
-        request,
+        id, auth_proto, request,
         base::Bind(&HomedirMethodsImpl::OnBaseReplyCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void UpdateKeyEx(const Identification& id,
                    const Authorization& auth,
                    const KeyDefinition& new_key,
                    const std::string& signature,
                    const Callback& callback) override {
-    cryptohome::AccountIdentifier id_proto;
     cryptohome::AuthorizationRequest auth_proto;
     cryptohome::UpdateKeyRequest pb_update_key;
 
-    FillIdentificationProtobuf(id, &id_proto);
     FillAuthorizationProtobuf(auth, &auth_proto);
     FillKeyProtobuf(new_key, pb_update_key.mutable_changes());
     pb_update_key.set_authorization_signature(signature);
 
     DBusThreadManager::Get()->GetCryptohomeClient()->UpdateKeyEx(
-        id_proto,
-        auth_proto,
-        pb_update_key,
+        id, auth_proto, pb_update_key,
         base::Bind(&HomedirMethodsImpl::OnBaseReplyCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  void RenameCryptohome(const Identification& id_from,
+                        const Identification& id_to,
+                        const Callback& callback) override {
+    DBusThreadManager::Get()->GetCryptohomeClient()->RenameCryptohome(
+        id_from, id_to, base::Bind(&HomedirMethodsImpl::OnBaseReplyCallback,
+                                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  private:
   void OnGetKeyDataExCallback(const GetKeyDataCallback& callback,
                               chromeos::DBusMethodCallStatus call_status,
                               bool result,
                               const BaseReply& reply) {
     if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
       callback.Run(false, MOUNT_ERROR_FATAL, std::vector<KeyDefinition>());
       return;
@@ skipping 161 matching lines @@
   }
   delete g_homedir_methods;
   g_homedir_methods = NULL;
   VLOG(1) << "HomedirMethods Shutdown completed";
 }
 
 // static
 HomedirMethods* HomedirMethods::GetInstance() { return g_homedir_methods; }
 
 }  // namespace cryptohome