[Easy signin] Wire up userClick auth attempt to easy unlock app and back

chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.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/easy_unlock/easy_unlock_key_manager.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 38 matching lines @@
   if (!RemoteDeviceListToDeviceDataList(remote_devices, &devices))
     devices.clear();
 
   // Only one pending request.
   DCHECK(!HasPendingOperations());
   create_keys_op_.reset(new EasyUnlockCreateKeysOperation(
       user_context,
       devices,
       base::Bind(&EasyUnlockKeyManager::OnKeysCreated,
                  weak_ptr_factory_.GetWeakPtr(),
-                 user_context,
-                 devices,
+                 devices.size(),
                  callback)));
   create_keys_op_->Start();
 }
 
 void EasyUnlockKeyManager::RemoveKeys(const UserContext& user_context,
                                       size_t start_index,
                                       const RemoveKeysCallback& callback) {
   // Must have the secret.
   DCHECK(!user_context.GetKey()->GetSecret().empty());
   // Only one pending request.
@@ skipping 107 matching lines @@
 
 bool EasyUnlockKeyManager::HasPendingOperations() const {
   return create_keys_op_ || remove_keys_op_ || !get_keys_ops_.empty();
 }
 
 int EasyUnlockKeyManager::GetNextOperationId() {
   return ++operation_id_;
 }
 
 void EasyUnlockKeyManager::OnKeysCreated(
-    const UserContext& user_context,
-    const EasyUnlockDeviceKeyDataList& devices,
+    size_t remove_start_index,
     const RefreshKeysCallback& callback,
     bool create_success) {
   scoped_ptr<EasyUnlockCreateKeysOperation> op = create_keys_op_.Pass();
   if (!callback.is_null())
     callback.Run(create_success);
 
   // Remove extra existing keys.
-  RemoveKeys(user_context, devices.size(), RemoveKeysCallback());
+  RemoveKeys(op->user_context(), remove_start_index, RemoveKeysCallback());

[Tim Song, 2014/09/23 19:37:59]

There might be a race condition here if RemoveKeys() is called again before this
operation finishes, so the first operation will be canceled.

Perhaps it would be a good idea to enforce that this manager only performs one
operation at any time.

[xiyuan, 2014/09/23 19:56:58]

Currently, we have a poor man's DCHECK(!HasPendingOperations()) in line 70 to
protect the case. Since key operations should only happen after user presents
credentials (and after a user confirmation UI in the future), the chances of the
racing is low.

[tbarzic, 2014/09/23 19:58:34]

I had a similar concern when this first got in, but afaik this is called only
once per session, so there should be ok (and there is a DCHECK for this in
RemoveKeys/RefreshKeys).

 }
 
 void EasyUnlockKeyManager::OnKeysRemoved(const RemoveKeysCallback& callback,
                                          bool remove_success) {
   scoped_ptr<EasyUnlockRemoveKeysOperation> op = remove_keys_op_.Pass();
   if (!callback.is_null())
     callback.Run(remove_success);
 }
 
 void EasyUnlockKeyManager::OnKeysFetched(
     int op_id,
     const GetDeviceDataListCallback& callback,
     bool fetch_success,
     const EasyUnlockDeviceKeyDataList& fetched_data) {
   std::map<int, EasyUnlockGetKeysOperation*>::iterator it =
       get_keys_ops_.find(op_id);
   scoped_ptr<EasyUnlockGetKeysOperation> op;
   if (it != get_keys_ops_.end()) {
     op.reset(it->second);
     get_keys_ops_.erase(it);
   } else {
     NOTREACHED();
   }
 
   if (!callback.is_null())
     callback.Run(fetch_success, fetched_data);
 }
 
 }  // namespace chromeos