Make the mapping from client id -> secret asynchronous.

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 "crypto/random.h"
 
 namespace remoting {
 namespace protocol {
 
 // How many bytes of random data to use for the client id and shared secret.
 const int kKeySize = 16;
 
-PairingRegistry::PairingRegistry(scoped_ptr<Delegate> delegate,
-                                 const PairedClients& paired_clients)
+PairingRegistry::PairingRegistry(scoped_ptr<Delegate> delegate)
     : delegate_(delegate.Pass()) {
   DCHECK(delegate_);
-  paired_clients_ = paired_clients;
 }
 
 PairingRegistry::~PairingRegistry() {
 }
 
-const PairingRegistry::Pairing& PairingRegistry::CreatePairing(
+PairingRegistry::Pairing PairingRegistry::CreatePairing(

[rmsousa, 2013/06/13 04:26:19]

Not for current CL:

This is now a very thin layer around the Delegate. The only piece of code in it
is actually a constructor for Pairing.

As it is now, it looks like this and Delegate could be combined in a single
interface. It also looks like implementations might be completely stateless,
eliminating the need for this to be a shared pointer, and letting each
authenticator/clientsession just have their own instance. But I think it's
better to wait until all the OS-specific implementations are done before
refactoring this, as it's possible we might find out we need an
intermediate/shared class after all.

[Jamie, 2013/06/13 17:22:15]

That's true. At one point there was some code here to check explicitly that
duplicate client ids are never generated, but since the probability of that was
so low, I removed it. I think you're right that the class isn't really needed
any more.

     const std::string& client_name) {
   DCHECK(CalledOnValidThread());
 
   Pairing result;
   result.client_name = client_name;
   result.client_id = base::GenerateGUID();
 
   // Create a random shared secret to authenticate this client.
   char buffer[kKeySize];
   crypto::RandBytes(buffer, arraysize(buffer));
   if (!base::Base64Encode(base::StringPiece(buffer, arraysize(buffer)),
                           &result.shared_secret)) {
     LOG(FATAL) << "Base64Encode failed.";
   }
 
   // Save the result via the Delegate and return it to the caller.
-  paired_clients_[result.client_id] = result;
-  delegate_->Save(paired_clients_);
-
-  return paired_clients_[result.client_id];
-}
-
-std::string PairingRegistry::GetSecret(const std::string& client_id) const {
-  DCHECK(CalledOnValidThread());
-
-  std::string result;
-  PairedClients::const_iterator i = paired_clients_.find(client_id);
-  if (i != paired_clients_.end()) {
-    result = i->second.shared_secret;
-  }
+  delegate_->AddPairing(result);
   return result;
 }
 
-void NotImplementedPairingRegistryDelegate::Save(
-    const PairingRegistry::PairedClients& paired_clients) {
+void PairingRegistry::GetPairing(const std::string& client_id,
+                                 const GetPairingCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  delegate_->GetPairing(client_id, callback);
+}
+
+void NotImplementedPairingRegistryDelegate::AddPairing(
+    const PairingRegistry::Pairing& new_paired_client) {
   NOTIMPLEMENTED();
 }
 
+void NotImplementedPairingRegistryDelegate::GetPairing(
+    const std::string& client_id,
+    const PairingRegistry::GetPairingCallback& callback) {
+  NOTIMPLEMENTED();
+  callback.Run(PairingRegistry::Pairing());
+}
+
+
 }  // namespace protocol
 }  // namespace remoting