Refactored PairingRegistry::Delegate such that it can retrieve/modify for a single client.

remoting/protocol/protocol_mock_objects.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 "remoting/protocol/protocol_mock_objects.h"
 
 namespace remoting {
 namespace protocol {
 
 MockConnectionToClient::MockConnectionToClient(
@@ skipping 30 matching lines @@
 MockVideoStub::~MockVideoStub() {}
 
 MockSession::MockSession() {}
 
 MockSession::~MockSession() {}
 
 MockSessionManager::MockSessionManager() {}
 
 MockSessionManager::~MockSessionManager() {}
 
-MockPairingRegistryDelegate::MockPairingRegistryDelegate()
-    : run_save_callback_automatically_(true) {
+MockPairingRegistryDelegate::MockPairingRegistryDelegate() {
 }
 
 MockPairingRegistryDelegate::~MockPairingRegistryDelegate() {
 }
 
+void MockPairingRegistryDelegate::LoadAll(
+    const protocol::PairingRegistry::GetAllPairingsCallback& callback) {
+  EXPECT_TRUE(pending_callback_.is_null());
+  pending_callback_ = base::Bind(
+      &MockPairingRegistryDelegate::DoLoadAll,
+      base::Unretained(this), callback);
+}
+
+void MockPairingRegistryDelegate::DeleteAll(
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  EXPECT_TRUE(pending_callback_.is_null());
+  pending_callback_ = base::Bind(
+      &MockPairingRegistryDelegate::DoDeleteAll,
+      base::Unretained(this), callback);
+}
+
+void MockPairingRegistryDelegate::Load(
+    const std::string& client_id,
+    const protocol::PairingRegistry::GetPairingCallback& callback) {
+  EXPECT_TRUE(pending_callback_.is_null());
+  pending_callback_ = base::Bind(
+      &MockPairingRegistryDelegate::DoLoad,
+      base::Unretained(this), client_id, callback);
+}
+
 void MockPairingRegistryDelegate::Save(
-    const std::string& pairings_json,
-    const PairingRegistry::SaveCallback& callback) {
-  EXPECT_TRUE(load_callback_.is_null());
-  EXPECT_TRUE(save_callback_.is_null());
-  if (run_save_callback_automatically_) {
-    SetPairingsJsonAndRunCallback(pairings_json, callback);
+    const protocol::PairingRegistry::Pairing& pairing,
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  EXPECT_TRUE(pending_callback_.is_null());
+  pending_callback_ = base::Bind(
+      &MockPairingRegistryDelegate::DoSave,
+      base::Unretained(this), pairing, callback);
+}
+
+void MockPairingRegistryDelegate::Delete(
+    const std::string& client_id,
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  EXPECT_TRUE(pending_callback_.is_null());
+  pending_callback_ = base::Bind(
+      &MockPairingRegistryDelegate::DoDelete,
+      base::Unretained(this), client_id, callback);
+}
+
+void MockPairingRegistryDelegate::DoLoadAll(
+    const protocol::PairingRegistry::GetAllPairingsCallback& callback) {
+  scoped_ptr<base::ListValue> result(new base::ListValue());
+  for (Pairings::const_iterator i = pairings_.begin(); i != pairings_.end();
+       ++i) {
+    protocol::PairingRegistry::Pairing sanitized_pairing(
+        i->second.created_time(),
+        i->second.client_name(),
+        i->second.client_id(),
+        "");

[Jamie, 2013/07/30 21:35:07]

The test that verifies that the shared secret is not returned is now only
testing this mock. I think it was better when the pairing registry took care of
that, meaning that it could be more easily unit tested.

[alexeypa (please no reviews), 2013/07/31 21:31:24]

Done.

+    result->Append(sanitized_pairing.EncodeJson().release());
+  }
+  callback.Run(result.Pass());
+}
+
+void MockPairingRegistryDelegate::DoDeleteAll(
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  pairings_.clear();
+  callback.Run(true);
+}
+
+void MockPairingRegistryDelegate::DoLoad(
+    const std::string& client_id,
+    const protocol::PairingRegistry::GetPairingCallback& callback) {
+  Pairings::const_iterator i = pairings_.find(client_id);
+  if (i != pairings_.end()) {
+    callback.Run(i->second);
   } else {
-    save_callback_ = base::Bind(
-        &MockPairingRegistryDelegate::SetPairingsJsonAndRunCallback,
-        base::Unretained(this), pairings_json, callback);
+    callback.Run(protocol::PairingRegistry::Pairing());
   }
 }
 
-void MockPairingRegistryDelegate::SetPairingsJsonAndRunCallback(
-    const std::string& pairings_json,
-    const PairingRegistry::SaveCallback& callback) {
-  pairings_json_ = pairings_json;
-  if (!callback.is_null()) {
-    callback.Run(true);
+void MockPairingRegistryDelegate::DoSave(
+    const protocol::PairingRegistry::Pairing& pairing,
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  pairings_[pairing.client_id()] = pairing;
+  callback.Run(true);
+}
+
+void MockPairingRegistryDelegate::DoDelete(
+    const std::string& client_id,
+    const protocol::PairingRegistry::DoneCallback& callback) {
+  pairings_.erase(client_id);
+  callback.Run(true);
+}
+
+void MockPairingRegistryDelegate::DrainCallbacks() {
+  base::Closure callback = pending_callback_;

[Jamie, 2013/07/30 21:35:07]

Nit: From the point of view of limiting the scope of variables as much as
possible, this can be moved inside the loop, which can instead be conditional on
pending_callback_.

[alexeypa (please no reviews), 2013/07/31 21:31:24]

Done.

+  while (!callback.is_null()) {
+    pending_callback_.Reset();
+    callback.Run();
+    callback = pending_callback_;
   }
 }
 
-void MockPairingRegistryDelegate::Load(
-    const PairingRegistry::LoadCallback& callback) {
-  EXPECT_TRUE(load_callback_.is_null());
-  EXPECT_TRUE(save_callback_.is_null());
-  load_callback_ = base::Bind(callback, pairings_json_);
-}
-
-void MockPairingRegistryDelegate::RunCallback() {
-  if (!load_callback_.is_null()) {
-    EXPECT_TRUE(save_callback_.is_null());
-    base::Closure load_callback = load_callback_;
-    load_callback_.Reset();
-    load_callback.Run();
-  } else if (!save_callback_.is_null()) {
-    EXPECT_TRUE(load_callback_.is_null());
-    base::Closure save_callback = save_callback_;
-    save_callback_.Reset();
-    save_callback.Run();
-  } else {
-    ADD_FAILURE() << "RunCallback called without any callbacks set.";
-  }
-}
-
 }  // namespace protocol
 }  // namespace remoting