Refactor ChannelAuthenticator so that it can be used with Authenticator.

remoting/protocol/channel_authenticator.cc

 // Copyright (c) 2011 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/channel_authenticator.h"
 
 #include "base/compiler_specific.h"
 #include "base/string_piece.h"
 #include "crypto/hmac.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/socket/ssl_client_socket.h"
-#include "net/socket/ssl_server_socket.h"
+#include "net/socket/ssl_socket.h"
 #include "net/socket/stream_socket.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Labels for use when exporting the SSL master keys.
 const char kClientSslExporterLabel[] = "EXPORTER-remoting-channel-auth-client";
 
@@ skipping 15 matching lines @@
     NOTREACHED() << "HMAC::Sign failed";
     return false;
   }
 
   auth_bytes->assign(out_bytes, out_bytes + kAuthDigestLength);
   return true;
 }
 
 }  // namespace
 
-HostChannelAuthenticator::HostChannelAuthenticator(net::SSLServerSocket* socket)
-    : socket_(socket),
+HostChannelAuthenticator::HostChannelAuthenticator(
+    const std::string& shared_secret)
+    : shared_secret_(shared_secret),
+      socket_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(auth_read_callback_(
           this, &HostChannelAuthenticator::OnAuthBytesRead)) {
 }
 
 HostChannelAuthenticator::~HostChannelAuthenticator() {
 }
 
-void HostChannelAuthenticator::Authenticate(const std::string& shared_secret,
+void HostChannelAuthenticator::Authenticate(net::SSLSocket* socket,
                                             const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
 
+  socket_ = socket;
   done_callback_ = done_callback;
 
   unsigned char key_material[kAuthDigestLength];
   int result = socket_->ExportKeyingMaterial(
       kClientSslExporterLabel, "", key_material, kAuthDigestLength);
   if (result != net::OK) {
     LOG(ERROR) << "Error fetching keying material: " << result;
     done_callback.Run(FAILURE);
     return;
   }
 
-  if (!GetAuthBytes(shared_secret,
+  if (!GetAuthBytes(shared_secret_,
                     std::string(key_material, key_material + kAuthDigestLength),
                     &auth_bytes_)) {
     done_callback.Run(FAILURE);
     return;
   }
 
   // Read an authentication digest.
   auth_read_buf_ = new net::GrowableIOBuffer();
   auth_read_buf_->SetCapacity(kAuthDigestLength);
   DoAuthRead();
@@ skipping 48 matching lines @@
   // Compare the received and expected digests in fixed time, to limit the
   // scope for timing attacks.
   uint8 result = 0;
   for (unsigned i = 0; i < auth_bytes_.length(); i++) {
     result |= received_auth_bytes[i] ^ auth_bytes_[i];
   }
   return result == 0;
 }
 
 ClientChannelAuthenticator::ClientChannelAuthenticator(
-    net::SSLClientSocket* socket)
-    : socket_(socket),
+    const std::string& shared_secret)
+    : shared_secret_(shared_secret),
+socket_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(auth_write_callback_(
         this, &ClientChannelAuthenticator::OnAuthBytesWritten)) {
 }
 
 ClientChannelAuthenticator::~ClientChannelAuthenticator() {
 }
 
 void ClientChannelAuthenticator::Authenticate(
-    const std::string& shared_secret,
+    net::SSLSocket* socket,
     const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
 
+  socket_ = socket;
   done_callback_ = done_callback;
 
   unsigned char key_material[kAuthDigestLength];
   int result = socket_->ExportKeyingMaterial(
       kClientSslExporterLabel, "", key_material, kAuthDigestLength);
   if (result != net::OK) {
     LOG(ERROR) << "Error fetching keying material: " << result;
     done_callback.Run(FAILURE);
     return;
   }
 
   std::string auth_bytes;
-  if (!GetAuthBytes(shared_secret,
+  if (!GetAuthBytes(shared_secret_,
                     std::string(key_material, key_material + kAuthDigestLength),
                     &auth_bytes)) {
     done_callback.Run(FAILURE);
     return;
   }
 
   // Allocate a buffer to write the authentication digest.
   auth_write_buf_ = new net::DrainableIOBuffer(
       new net::StringIOBuffer(auth_bytes), auth_bytes.size());
   DoAuthWrite();
@@ skipping 28 matching lines @@
   auth_write_buf_->DidConsume(result);
   if (auth_write_buf_->BytesRemaining() > 0)
     return true;
 
   done_callback_.Run(SUCCESS);
   return false;
 }
 
 }  // namespace protocol
 }  // namespace remoting