Add serialization to PairingRegistry.

remoting/protocol/pairing_registry.h

 // 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.
 
 #ifndef REMOTING_PROTOCOL_PAIRING_REGISTRY_H_
 #define REMOTING_PROTOCOL_PAIRING_REGISTRY_H_
 
 #include <map>
+#include <queue>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 
@@ skipping 101 matching lines @@
   void ClearAllPairings(const SaveCallback& callback);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(PairingRegistryTest, AddPairing);
   FRIEND_TEST_ALL_PREFIXES(PairingRegistryTest, GetAllPairingsJSON);
   friend class NegotiatingAuthenticatorTest;
   friend class base::RefCountedThreadSafe<PairingRegistry>;
 
   virtual ~PairingRegistry();
 
+  // Helper method for unit tests.
   void AddPairing(const Pairing& pairing);
+
+  // Worker functions for each of the public methods, passed as a callback to
+  // the delegate.
   void MergePairingAndSave(const Pairing& pairing,
+                           const SaveCallback& callback,
                            const std::string& pairings_json);
   void DoGetPairing(const std::string& client_id,
                     const GetPairingCallback& callback,
                     const std::string& pairings_json);
   void SanitizePairings(const GetAllPairingsCallback& callback,
                         const std::string& pairings_json);
   void DoDeletePairing(const std::string& client_id,
                        const SaveCallback& callback,
                        const std::string& pairings_json);
 
+  // "Trampoline" callbacks that schedule the next pending request and then
+  // invoke the original caller-supplied callback.
+  void InvokeLoadCallbackAndScheduleNext(
+      const LoadCallback& callback, const std::string& pairings_json);
+  void InvokeSaveCallbackAndScheduleNext(
+      const SaveCallback& callback, bool success);
+  void InvokeGetPairingCallbackAndScheduleNext(
+      const GetPairingCallback& callback, Pairing pairing);
+  void InvokeGetAllPairingsCallbackAndScheduleNext(
+      const GetAllPairingsCallback& callback,
+      scoped_ptr<base::ListValue> pairings);
+
+  // Queue management methods.
+  void ServiceOrQueueRequest(const base::Closure& request);
+  void ServiceNextRequest();
+
   // Translate between the structured and serialized forms of the pairing data.
   static PairedClients DecodeJson(const std::string& pairings_json);
   static std::string EncodeJson(const PairedClients& clients);
   static scoped_ptr<base::ListValue> ConvertToListValue(
       const PairedClients& clients,
       bool include_shared_secrets);
 
   scoped_ptr<Delegate> delegate_;
 
+  std::queue<base::Closure> pending_requests_;
+
   DISALLOW_COPY_AND_ASSIGN(PairingRegistry);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_PAIRING_REGISTRY_H_