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

chrome/test/base/testing_profile.cc

 // Copyright (c) 2012 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/test/base/testing_profile.h"
 
 #include <utility>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 114 matching lines @@
 
 using base::Time;
 using bookmarks::BookmarkModel;
 using content::BrowserThread;
 using content::DownloadManagerDelegate;
 using testing::NiceMock;
 using testing::Return;
 
 namespace {
 
+// Default profile name
+const char kTestingProfile[] = "testing_profile";
+
 // Task used to make sure history has finished processing a request. Intended
 // for use with BlockUntilHistoryProcessesPendingRequests.
 
 class QuittingHistoryDBTask : public history::HistoryDBTask {
  public:
   QuittingHistoryDBTask() {}
 
   bool RunOnDBThread(history::HistoryBackend* backend,
                      history::HistoryDatabase* db) override {
     return true;
@@ skipping 106 matching lines @@
 TestingProfile::TestingProfile()
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
-      delegate_(NULL) {
+      delegate_(NULL),
+      profile_name_(kTestingProfile) {
   CreateTempProfileDir();
   profile_path_ = temp_dir_.path();
 
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const base::FilePath& path)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
-      delegate_(NULL) {
+      delegate_(NULL),
+      profile_name_(kTestingProfile) {
   Init();
   FinishInit();
 }
 
-TestingProfile::TestingProfile(const base::FilePath& path,
-                               Delegate* delegate)
+TestingProfile::TestingProfile(const base::FilePath& path, Delegate* delegate)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
-      delegate_(delegate) {
+      delegate_(delegate),
+      profile_name_(kTestingProfile) {
   Init();
   if (delegate_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TestingProfile::FinishInit, base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
 TestingProfile::TestingProfile(
     const base::FilePath& path,
     Delegate* delegate,
 #if defined(ENABLE_EXTENSIONS)
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
 #endif
     scoped_ptr<syncable_prefs::PrefServiceSyncable> prefs,
     TestingProfile* parent,
     bool guest_session,
     const std::string& supervised_user_id,
     scoped_ptr<policy::PolicyService> policy_service,
-    const TestingFactories& factories)
+    const TestingFactories& factories,
+    const std::string& profile_name)
     : start_time_(Time::Now()),
       prefs_(prefs.release()),
       testing_prefs_(NULL),
       force_incognito_(false),
       original_profile_(parent),
       guest_session_(guest_session),
       last_session_exited_cleanly_(true),
 #if defined(ENABLE_EXTENSIONS)
       extension_special_storage_policy_(extension_policy),
 #endif
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
       delegate_(delegate),
+      profile_name_(profile_name),
       policy_service_(policy_service.release()) {
   if (parent)
     parent->SetOffTheRecordProfile(scoped_ptr<Profile>(this));
 
   // If no profile path was supplied, create one.
   if (profile_path_.empty()) {
     CreateTempProfileDir();
     profile_path_ = temp_dir_.path();
   }
 
@@ skipping 123 matching lines @@
 
 #if defined(ENABLE_SUPERVISED_USERS)
   if (!IsOffTheRecord()) {
     SupervisedUserSettingsService* settings_service =
         SupervisedUserSettingsServiceFactory::GetForProfile(this);
     TestingPrefStore* store = new TestingPrefStore();
     settings_service->Init(store);
     store->SetInitializationCompleted();
   }
 #endif
-
-  profile_name_ = "testing_profile";
 }
 
 void TestingProfile::FinishInit() {
   DCHECK(content::NotificationService::current());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::NotificationService::NoDetails());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
@@ skipping 478 matching lines @@
   return guest_session_;
 }
 
 Profile::ExitType TestingProfile::GetLastSessionExitType() {
   return last_session_exited_cleanly_ ? EXIT_NORMAL : EXIT_CRASHED;
 }
 
 TestingProfile::Builder::Builder()
     : build_called_(false),
       delegate_(NULL),
-      guest_session_(false) {
-}
+      guest_session_(false),
+      profile_name_(kTestingProfile) {}
 
 TestingProfile::Builder::~Builder() {
 }
 
 void TestingProfile::Builder::SetPath(const base::FilePath& path) {
   path_ = path;
 }
 
 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
@@ skipping 18 matching lines @@
 void TestingProfile::Builder::SetSupervisedUserId(
     const std::string& supervised_user_id) {
   supervised_user_id_ = supervised_user_id;
 }
 
 void TestingProfile::Builder::SetPolicyService(
     scoped_ptr<policy::PolicyService> policy_service) {
   policy_service_ = std::move(policy_service);
 }
 
+void TestingProfile::Builder::SetProfileName(const std::string& profile_name) {
+  profile_name_ = profile_name;
+}
+
 void TestingProfile::Builder::AddTestingFactory(
     BrowserContextKeyedServiceFactory* service_factory,
     BrowserContextKeyedServiceFactory::TestingFactoryFunction callback) {
   testing_factories_.push_back(std::make_pair(service_factory, callback));
 }
 
 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
   DCHECK(!build_called_);
   build_called_ = true;
 
   return scoped_ptr<TestingProfile>(new TestingProfile(
       path_, delegate_,
 #if defined(ENABLE_EXTENSIONS)
       extension_policy_,
 #endif
       std::move(pref_service_), NULL, guest_session_, supervised_user_id_,
-      std::move(policy_service_), testing_factories_));
+      std::move(policy_service_), testing_factories_, profile_name_));
 }
 
 TestingProfile* TestingProfile::Builder::BuildIncognito(
     TestingProfile* original_profile) {
   DCHECK(!build_called_);
   DCHECK(original_profile);
   build_called_ = true;
 
   // Note: Owned by |original_profile|.
   return new TestingProfile(path_, delegate_,
 #if defined(ENABLE_EXTENSIONS)
                             extension_policy_,
 #endif
                             std::move(pref_service_), original_profile,
                             guest_session_, supervised_user_id_,
-                            std::move(policy_service_), testing_factories_);
+                            std::move(policy_service_), testing_factories_,
+                            profile_name_);
 }