Tame the proliferation of UserContext constructors

chrome/browser/chromeos/login/auth/extended_authenticator.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/extended_authenticator.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/chromeos/boot_times_loader.h"
@@ skipping 90 matching lines @@
 
   RecordStartMarker("MountEx");
 
   std::string canonicalized = gaia::CanonicalizeEmail(user_id);
   cryptohome::Identification id(canonicalized);
   cryptohome::Authorization auth(keys.front());
   cryptohome::MountParameters mount(false);
   for (size_t i = 0; i < keys.size(); i++) {
     mount.create_keys.push_back(keys[i]);
   }
-  UserContext context(user_id, keys.front().key, std::string());
+  UserContext context(user_id);
+  context.SetPassword(keys.front().key);
   context.SetKeyLabel(keys.front().label);
 
   cryptohome::HomedirMethods::GetInstance()->MountEx(
       id,
       auth,
       mount,
       base::Bind(&ExtendedAuthenticator::OnMountComplete,
                  this,
                  "MountEx",
                  context,
@@ skipping 160 matching lines @@
 void ExtendedAuthenticator::OnMountComplete(
     const std::string& time_marker,
     const UserContext& user_context,
     const HashSuccessCallback& success_callback,
     bool success,
     cryptohome::MountError return_code,
     const std::string& mount_hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   RecordEndMarker(time_marker);
-  UserContext copy;
-  copy.CopyFrom(user_context);
+  UserContext copy = user_context;
   copy.SetUserIDHash(mount_hash);
   if (return_code == cryptohome::MOUNT_ERROR_NONE) {
     if (!success_callback.is_null())
       success_callback.Run(mount_hash);
     if (old_consumer_)
       old_consumer_->OnLoginSuccess(copy);
     return;
   }
   AuthState state = FAILED_MOUNT;
   if (return_code == cryptohome::MOUNT_ERROR_TPM_COMM_ERROR ||
@@ skipping 70 matching lines @@
                               callback),
                    system_salt_);
   }
 }
 
 void ExtendedAuthenticator::DidTransformContext(
     const UserContext& user_context,
     const ContextCallback& callback,
     const std::string& hashed_password) {
   DCHECK(user_context.DoesNeedPasswordHashing());
-  UserContext context;
-  context.CopyFrom(user_context);
+  UserContext context = user_context;
   context.SetPassword(hashed_password);
   context.SetDoesNeedPasswordHashing(false);
   callback.Run(context);
 }
 
 void ExtendedAuthenticator::DoHashWithSalt(const std::string& password,
                                            const HashSuccessCallback& callback,
                                            const std::string& system_salt) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (salt_obtained_) {
     std::string hash =
         ParallelAuthenticator::HashPassword(password, system_salt);
     callback.Run(hash);
     return;
   }
   hashing_queue_.push_back(base::Bind(
       &ExtendedAuthenticator::DoHashWithSalt, this, password, callback));
 }
 
 }  // namespace chromeos