Remove V1 authenticators

remoting/protocol/ssl_hmac_channel_authenticator.cc

 // Copyright (c) 2012 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/ssl_hmac_channel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "crypto/secure_util.h"
 #include "net/base/cert_verifier.h"
@@ skipping 29 matching lines @@
   scoped_ptr<SslHmacChannelAuthenticator> result(
       new SslHmacChannelAuthenticator(auth_key));
   result->local_cert_ = local_cert;
   result->local_private_key_ = local_private_key;
   return result.Pass();
 }
 
 SslHmacChannelAuthenticator::SslHmacChannelAuthenticator(
     const std::string& auth_key)
     : auth_key_(auth_key),
-      local_private_key_(NULL),
-      legacy_mode_(NONE) {
+      local_private_key_(NULL) {
 }
 
 SslHmacChannelAuthenticator::~SslHmacChannelAuthenticator() {
 }
 
-void SslHmacChannelAuthenticator::SetLegacyOneWayMode(LegacyMode legacy_mode) {
-  // Must be called before SecureAndAuthenticate().
-  DCHECK(done_callback_.is_null());
-  legacy_mode_ = legacy_mode;
-}
-
 void SslHmacChannelAuthenticator::SecureAndAuthenticate(
     scoped_ptr<net::StreamSocket> socket, const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket->IsConnected());
 
   done_callback_ = done_callback;
 
   int result;
   if (is_ssl_server()) {
     scoped_refptr<net::X509Certificate> cert =
@@ skipping 50 matching lines @@
   return local_private_key_ != NULL;
 }
 
 void SslHmacChannelAuthenticator::OnConnected(int result) {
   if (result != net::OK) {
     LOG(WARNING) << "Failed to establish SSL connection";
     NotifyError(result);
     return;
   }
 
-  if (legacy_mode_ != RECEIVE_ONLY) {
-    // Generate authentication digest to write to the socket.
-    std::string auth_bytes = GetAuthBytes(
-        socket_.get(), is_ssl_server() ?
-        kHostAuthSslExporterLabel : kClientAuthSslExporterLabel, auth_key_);
-    if (auth_bytes.empty()) {
-      NotifyError(net::ERR_FAILED);
-      return;
-    }
-
-    // Allocate a buffer to write the digest.
-    auth_write_buf_ = new net::DrainableIOBuffer(
-        new net::StringIOBuffer(auth_bytes), auth_bytes.size());
+  // Generate authentication digest to write to the socket.
+  std::string auth_bytes = GetAuthBytes(
+      socket_.get(), is_ssl_server() ?
+      kHostAuthSslExporterLabel : kClientAuthSslExporterLabel, auth_key_);
+  if (auth_bytes.empty()) {
+    NotifyError(net::ERR_FAILED);
+    return;
   }
 
-  if (legacy_mode_ != SEND_ONLY) {
-    // Read an incoming token.
-    auth_read_buf_ = new net::GrowableIOBuffer();
-    auth_read_buf_->SetCapacity(kAuthDigestLength);
-  }
+  // Allocate a buffer to write the digest.
+  auth_write_buf_ = new net::DrainableIOBuffer(
+      new net::StringIOBuffer(auth_bytes), auth_bytes.size());
+
+  // Read an incoming token.
+  auth_read_buf_ = new net::GrowableIOBuffer();
+  auth_read_buf_->SetCapacity(kAuthDigestLength);
 
   // If WriteAuthenticationBytes() results in |done_callback_| being
   // called then we must not do anything else because this object may
   // be destroyed at that point.
   bool callback_called = false;
-  if (legacy_mode_ != RECEIVE_ONLY)
-    WriteAuthenticationBytes(&callback_called);
-  if (!callback_called && legacy_mode_ != SEND_ONLY)
+  WriteAuthenticationBytes(&callback_called);
+  if (!callback_called)
     ReadAuthenticationBytes();
 }
 
 void SslHmacChannelAuthenticator::WriteAuthenticationBytes(
     bool* callback_called) {
   while (true) {
     int result = socket_->Write(
         auth_write_buf_, auth_write_buf_->BytesRemaining(),
         base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesWritten,
                    base::Unretained(this)));
@@ skipping 98 matching lines @@
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   done_callback_.Run(static_cast<net::Error>(error),
                      scoped_ptr<net::StreamSocket>(NULL));
 }
 
 }  // namespace protocol
 }  // namespace remoting