Add serialization to PairingRegistry.

remoting/protocol/pairing_registry.cc

Index: remoting/protocol/pairing_registry.cc
diff --git a/remoting/protocol/pairing_registry.cc b/remoting/protocol/pairing_registry.cc
index 24875aa1ba5b43eb2a74c7adbeb74627f432ad3b..05b7d38f41b2121c95839c19336a2b5236f9fd7c 100644
--- a/remoting/protocol/pairing_registry.cc
+++ b/remoting/protocol/pairing_registry.cc
@@ -65,7 +65,8 @@ bool PairingRegistry::Pairing::is_valid() const {
 }
 
 PairingRegistry::PairingRegistry(scoped_ptr<Delegate> delegate)
-    : delegate_(delegate.Pass()) {
+    : delegate_(delegate.Pass()),
+      servicing_request_(false) {
   DCHECK(delegate_);
 }
 
@@ -83,41 +84,105 @@ PairingRegistry::Pairing PairingRegistry::CreatePairing(
 void PairingRegistry::GetPairing(const std::string& client_id,
                                  const GetPairingCallback& callback) {
   DCHECK(CalledOnValidThread());
+  GetPairingCallback wrapped_callback = base::Bind(
+      &PairingRegistry::InvokeGetPairingCallbackAndScheduleNext,
+      this, callback);
+  base::Closure request = base::Bind(
+      &PairingRegistry::GetPairingAndScheduleNext,
+      this, client_id, wrapped_callback);
+  ServiceOrQueueRequest(request);
+}
+
+void PairingRegistry::GetAllPairings(
+    const GetAllPairingsCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  GetAllPairingsCallback wrapped_callback = base::Bind(
+      &PairingRegistry::InvokeGetAllPairingsCallbackAndScheduleNext,
+      this, callback);
+  base::Closure request = base::Bind(
+      &PairingRegistry::GetAllPairingsAndScheduleNext,
+      this, wrapped_callback);
+  ServiceOrQueueRequest(request);
+}
+
+void PairingRegistry::DeletePairing(
+    const std::string& client_id, const SaveCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  SaveCallback wrapped_callback = base::Bind(
+      &PairingRegistry::InvokeSaveCallbackAndScheduleNext,
+      this, callback);
+  base::Closure request = base::Bind(
+      &PairingRegistry::DeletePairingAndScheduleNext,
+      this, client_id, wrapped_callback);
+  ServiceOrQueueRequest(request);
+}
+
+void PairingRegistry::ClearAllPairings(
+    const SaveCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  SaveCallback wrapped_callback = base::Bind(
+      &PairingRegistry::InvokeSaveCallbackAndScheduleNext,
+      this, callback);
+  base::Closure request = base::Bind(
+      &PairingRegistry::ClearAllPairingsAndScheduleNext,
+      this, wrapped_callback);
+  ServiceOrQueueRequest(request);
+}
+
+void PairingRegistry::AddPairing(const Pairing& pairing) {
+  SaveCallback callback = base::Bind(
+      &PairingRegistry::InvokeSaveCallbackAndScheduleNext,
+      this, SaveCallback());
+  base::Closure request = base::Bind(
+      &PairingRegistry::SavePairingAndScheduleNext,
+      this, pairing, callback);
+  ServiceOrQueueRequest(request);
+}
+
+void PairingRegistry::SavePairingAndScheduleNext(Pairing pairing,
+                                                 const SaveCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  delegate_->Load(
+      base::Bind(&PairingRegistry::MergePairingAndSave,
+                 this, pairing, callback));
+}
+
+void PairingRegistry::GetPairingAndScheduleNext(
+    const std::string& client_id, const GetPairingCallback& callback) {
+  DCHECK(CalledOnValidThread());
   delegate_->Load(
       base::Bind(&PairingRegistry::DoGetPairing, this, client_id, callback));
 }
 
-void PairingRegistry::GetAllPairings(const GetAllPairingsCallback& callback) {
+void PairingRegistry::GetAllPairingsAndScheduleNext(
+    const GetAllPairingsCallback& callback) {
   DCHECK(CalledOnValidThread());
   delegate_->Load(
       base::Bind(&PairingRegistry::SanitizePairings, this, callback));
 }
 
-void PairingRegistry::DeletePairing(const std::string& client_id,
-                                    const SaveCallback& callback) {
+void PairingRegistry::DeletePairingAndScheduleNext(
+    const std::string& client_id, const SaveCallback& callback) {
   DCHECK(CalledOnValidThread());
   delegate_->Load(
       base::Bind(&PairingRegistry::DoDeletePairing,
                  this, client_id, callback));
 }
 
-void PairingRegistry::ClearAllPairings(const SaveCallback& callback) {
+void PairingRegistry::ClearAllPairingsAndScheduleNext(
+    const SaveCallback& callback) {
   DCHECK(CalledOnValidThread());
   delegate_->Save(EncodeJson(PairedClients()), callback);
 }
 
-void PairingRegistry::AddPairing(const Pairing& pairing) {
-  delegate_->Load(
-      base::Bind(&PairingRegistry::MergePairingAndSave, this, pairing));
-}
-
 void PairingRegistry::MergePairingAndSave(const Pairing& pairing,
+                                          const SaveCallback& callback,
                                           const std::string& pairings_json) {
   DCHECK(CalledOnValidThread());
   PairedClients clients = DecodeJson(pairings_json);
   clients[pairing.client_id()] = pairing;
   std::string new_pairings_json = EncodeJson(clients);
-  delegate_->Save(new_pairings_json, SaveCallback());
+  delegate_->Save(new_pairings_json, callback);
 }
 
 void PairingRegistry::DoGetPairing(const std::string& client_id,
@@ -143,6 +208,38 @@ void PairingRegistry::DoDeletePairing(const std::string& client_id,
   delegate_->Save(new_pairings_json, callback);
 }
 
+void PairingRegistry::InvokeLoadCallbackAndScheduleNext(
+    const LoadCallback& callback, const std::string& pairings_json) {
+  callback.Run(pairings_json);
+  servicing_request_ = false;
+  ServiceNextRequest();
+}
+
+void PairingRegistry::InvokeSaveCallbackAndScheduleNext(
+    const SaveCallback& callback, bool success) {
+  // CreatePairing doesn't have a callback, so the callback can be null.
+  if (!callback.is_null()) {
+    callback.Run(success);
+  }
+  servicing_request_ = false;
+  ServiceNextRequest();
+}
+
+void PairingRegistry::InvokeGetPairingCallbackAndScheduleNext(
+    const GetPairingCallback& callback, Pairing pairing) {
+  callback.Run(pairing);
+  servicing_request_ = false;
+  ServiceNextRequest();
+}
+
+void PairingRegistry::InvokeGetAllPairingsCallbackAndScheduleNext(
+    const GetAllPairingsCallback& callback,
+    scoped_ptr<base::ListValue> pairings) {
+  callback.Run(pairings.Pass());
+  servicing_request_ = false;
+  ServiceNextRequest();
+}
+
 // static
 PairingRegistry::PairedClients PairingRegistry::DecodeJson(
     const std::string& pairings_json) {
@@ -189,6 +286,23 @@ PairingRegistry::PairedClients PairingRegistry::DecodeJson(
   return result;
 }
 
+void PairingRegistry::ServiceOrQueueRequest(const base::Closure& request) {
+  pending_requests_.push(request);
+  if (!servicing_request_) {
+    ServiceNextRequest();
+  }
+}
+
+void PairingRegistry::ServiceNextRequest() {
+  if (pending_requests_.empty()) {
+    return;
+  }
+  servicing_request_ = true;
+  base::Closure request = pending_requests_.front();
+  pending_requests_.pop();
+  request.Run();
+}
+
 // static
 std::string PairingRegistry::EncodeJson(const PairedClients& clients) {
   scoped_ptr<base::ListValue> root = ConvertToListValue(clients, true);