Add serialization to PairingRegistry.

remoting/protocol/pairing_registry.cc

 // Copyright 2013 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/pairing_registry.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 47 matching lines @@
          client_id_ == other.client_id_ &&
          client_name_ == other.client_name_ &&
          shared_secret_ == other.shared_secret_;
 }
 
 bool PairingRegistry::Pairing::is_valid() const {
   return !client_id_.empty() && !shared_secret_.empty();
 }
 
 PairingRegistry::PairingRegistry(scoped_ptr<Delegate> delegate)
-    : delegate_(delegate.Pass()) {
+    : delegate_(delegate.Pass()),
+      servicing_request_(false) {
   DCHECK(delegate_);
 }
 
 PairingRegistry::~PairingRegistry() {
 }
 
 PairingRegistry::Pairing PairingRegistry::CreatePairing(
     const std::string& client_name) {
   DCHECK(CalledOnValidThread());
   Pairing result = Pairing::Create(client_name);
   AddPairing(result);
   return result;
 }
 
 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,
                                    const GetPairingCallback& callback,
                                    const std::string& pairings_json) {
   PairedClients clients = DecodeJson(pairings_json);
   Pairing result = clients[client_id];
   callback.Run(result);
 }
 
 void PairingRegistry::SanitizePairings(const GetAllPairingsCallback& callback,
                                        const std::string& pairings_json) {
   PairedClients clients = DecodeJson(pairings_json);
   callback.Run(ConvertToListValue(clients, false));
 }
 
 void PairingRegistry::DoDeletePairing(const std::string& client_id,
                                       const SaveCallback& callback,
                                       const std::string& pairings_json) {
   PairedClients clients = DecodeJson(pairings_json);
   clients.erase(client_id);
   std::string new_pairings_json = EncodeJson(clients);
   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) {
   PairedClients result;
 
   if (pairings_json.empty()) {
     return result;
   }
 
   JSONStringValueSerializer registry(pairings_json);
@@ skipping 26 matching lines @@
       result[client_id] = Pairing(
           created_time, client_name, client_id, shared_secret);
     } else {
       LOG(ERROR) << "Paired client " << i << " has unexpected format.";
     }
   }
 
   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);
   std::string result;
   JSONStringValueSerializer serializer(&result);
   serializer.Serialize(*root);
 
   return result;
 }
 
@@ skipping 11 matching lines @@
     if (include_shared_secrets) {
       pairing->SetString(kSharedSecretKey, i->second.shared_secret());
     }
     root->Append(pairing);
   }
   return root.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting