Clean up Smart Lock cryptohome keys logic:

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/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_factory.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kKeyBluetoothAddress[] = "bluetoothAddress";
 const char kKeyPermitRecord[] = "permitRecord";
 const char kKeyPermitId[] = "permitRecord.id";
 const char kKeyPermitPermitId[] = "permitRecord.permitId";
 const char kKeyPermitData[] = "permitRecord.data";
 const char kKeyPermitType[] = "permitRecord.type";
 const char kKeyPsk[] = "psk";
 
 const char kKeyLabelPrefix[] = "easy-unlock-";
 
 const char kPermitPermitIdFormat[] = "permit://google.com/easyunlock/v1/%s";
 const char kPermitTypeLicence[] = "licence";
 
 }  // namespace
 
 EasyUnlockKeyManager::EasyUnlockKeyManager()
-    : operation_id_(0),
+    : write_queue_deleter_(&write_operation_queue_),
+      read_queue_deleter_(&read_operation_queue_),
       weak_ptr_factory_(this) {
 }
 
 EasyUnlockKeyManager::~EasyUnlockKeyManager() {
-  STLDeleteContainerPairSecondPointers(get_keys_ops_.begin(),
-                                       get_keys_ops_.end());
 }
 
 void EasyUnlockKeyManager::RefreshKeys(const UserContext& user_context,
                                        const base::ListValue& remote_devices,
                                        const RefreshKeysCallback& callback) {
-  // Must have the secret.
-  DCHECK(!user_context.GetKey()->GetSecret().empty());
-
   base::Closure do_refresh_keys = base::Bind(
       &EasyUnlockKeyManager::RefreshKeysWithTpmKeyPresent,
       weak_ptr_factory_.GetWeakPtr(),
       user_context,
       base::Owned(remote_devices.DeepCopy()),
       callback);
 
   EasyUnlockTpmKeyManager* tpm_key_manager =
       EasyUnlockTpmKeyManagerFactory::GetInstance()->GetForUser(
           user_context.GetUserID());
@@ skipping 24 matching lines @@
   EasyUnlockTpmKeyManager* tpm_key_manager =
       EasyUnlockTpmKeyManagerFactory::GetInstance()->GetForUser(
           user_context.GetUserID());
   std::string tpm_public_key =
       tpm_key_manager->GetPublicTpmKey(user_context.GetUserID());
 
   EasyUnlockDeviceKeyDataList devices;
   if (!RemoteDeviceListToDeviceDataList(*remote_devices, &devices))
     devices.clear();
 
-  // Only one pending request.
-  DCHECK(!HasPendingOperations());
-  create_keys_op_.reset(new EasyUnlockCreateKeysOperation(
-      user_context,
-      tpm_public_key,
-      devices,
-      base::Bind(&EasyUnlockKeyManager::OnKeysCreated,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 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.
-  DCHECK(!HasPendingOperations());
-
-  remove_keys_op_.reset(
-      new EasyUnlockRemoveKeysOperation(
-          user_context,
-          start_index,
-          base::Bind(&EasyUnlockKeyManager::OnKeysRemoved,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback)));
-  remove_keys_op_->Start();
+  write_operation_queue_.push_back(new EasyUnlockRefreshKeysOperation(
+      user_context, tpm_public_key, devices,
+      base::Bind(&EasyUnlockKeyManager::OnKeysRefreshed,
+                 weak_ptr_factory_.GetWeakPtr(), callback)));
+  RunNextOperation();
 }
 
 void EasyUnlockKeyManager::GetDeviceDataList(
     const UserContext& user_context,
     const GetDeviceDataListCallback& callback) {
-  // Defer the get operation if there is pending write operations.
-  if (create_keys_op_ || remove_keys_op_) {
-    pending_ops_.push_back(base::Bind(&EasyUnlockKeyManager::GetDeviceDataList,
-                                      weak_ptr_factory_.GetWeakPtr(),
-                                      user_context,
-                                      callback));
-    return;
-  }
-
-  const int op_id = GetNextOperationId();
-  scoped_ptr<EasyUnlockGetKeysOperation> op(new EasyUnlockGetKeysOperation(
-      user_context,
-      base::Bind(&EasyUnlockKeyManager::OnKeysFetched,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 op_id,
-                 callback)));
-  op->Start();
-  get_keys_ops_[op_id] = op.release();
+  read_operation_queue_.push_back(new EasyUnlockGetKeysOperation(
+      user_context, base::Bind(&EasyUnlockKeyManager::OnKeysFetched,
+                               weak_ptr_factory_.GetWeakPtr(), callback)));
+  RunNextOperation();
 }
 
 // static
 void EasyUnlockKeyManager::DeviceDataToRemoteDeviceDictionary(
     const std::string& user_id,
     const EasyUnlockDeviceKeyData& data,
     base::DictionaryValue* dict) {
   dict->SetString(kKeyBluetoothAddress, data.bluetooth_address);
   dict->SetString(kKeyPsk, data.psk);
   scoped_ptr<base::DictionaryValue> permit_record(new base::DictionaryValue);
@@ skipping 61 matching lines @@
 
   data_list->swap(parsed_devices);
   return true;
 }
 
 // static
 std::string EasyUnlockKeyManager::GetKeyLabel(size_t key_index) {
   return base::StringPrintf("%s%zu", kKeyLabelPrefix, key_index);
 }
 
-bool EasyUnlockKeyManager::HasPendingOperations() const {
-  return create_keys_op_ || remove_keys_op_ || !get_keys_ops_.empty();
+void EasyUnlockKeyManager::RunNextOperation() {
+  if (pending_write_operation_ || pending_read_operation_)
+    return;
+
+  if (!write_operation_queue_.empty()) {
+    pending_write_operation_ = make_scoped_ptr(write_operation_queue_.front());
+    write_operation_queue_.pop_front();
+    pending_write_operation_->Start();
+  } else if (!read_operation_queue_.empty()) {
+    pending_read_operation_ = make_scoped_ptr(read_operation_queue_.front());
+    read_operation_queue_.pop_front();
+    pending_read_operation_->Start();
+  }
 }
 
-int EasyUnlockKeyManager::GetNextOperationId() {
-  return ++operation_id_;
-}
+void EasyUnlockKeyManager::OnKeysRefreshed(const RefreshKeysCallback& callback,
+                                           bool refresh_success) {
+  if (!callback.is_null())
+    callback.Run(refresh_success);
 
-void EasyUnlockKeyManager::RunNextPendingOp() {
-  if (pending_ops_.empty())
-    return;
-
-  pending_ops_.front().Run();
-  pending_ops_.pop_front();
-}
-
-void EasyUnlockKeyManager::OnKeysCreated(
-    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(op->user_context(), remove_start_index, RemoveKeysCallback());
-}
-
-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);
-
-  if (!HasPendingOperations())
-    RunNextPendingOp();
+  DCHECK(pending_write_operation_);
+  pending_write_operation_.reset();
+  RunNextOperation();
 }
 
 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);
 
-  if (!HasPendingOperations())
-    RunNextPendingOp();
+  DCHECK(pending_read_operation_);
+  pending_read_operation_.reset();
+  RunNextOperation();
 }
 
 }  // namespace chromeos