Move PseudoTCP and channel auth out of LibjingleTransportFactory.

remoting/protocol/ssl_hmac_channel_authenticator_unittest.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/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 18 matching lines @@
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kTestSharedSecret[] = "1234-1234-5678";
 const char kTestSharedSecretBad[] = "0000-0000-0001";
 
 class MockChannelDoneCallback {
  public:
-  MOCK_METHOD2(OnDone, void(net::Error error, net::StreamSocket* socket));
+  MOCK_METHOD2(OnDone, void(int error, net::StreamSocket* socket));
 };
 
 ACTION_P(QuitThreadOnCounter, counter) {
   --(*counter);
   EXPECT_GE(*counter, 0);
   if (*counter == 0)
     base::MessageLoop::current()->Quit();
 }
 
 }  // namespace
@@ skipping 25 matching lines @@
     client_fake_socket_->PairWith(host_fake_socket_.get());
 
     client_auth_->SecureAndAuthenticate(
         client_fake_socket_.PassAs<net::StreamSocket>(),
         base::Bind(&SslHmacChannelAuthenticatorTest::OnClientConnected,
                    base::Unretained(this)));
 
     host_auth_->SecureAndAuthenticate(
         host_fake_socket_.PassAs<net::StreamSocket>(),
         base::Bind(&SslHmacChannelAuthenticatorTest::OnHostConnected,
-                   base::Unretained(this)));
+                   base::Unretained(this), std::string("ref argument value")));
 
     // Expect two callbacks to be called - the client callback and the host
     // callback.
     int callback_counter = 2;
 
     if (expected_fail) {
       EXPECT_CALL(client_callback_, OnDone(net::ERR_FAILED, NULL))
           .WillOnce(QuitThreadOnCounter(&callback_counter));
       EXPECT_CALL(host_callback_, OnDone(net::ERR_FAILED, NULL))
           .WillOnce(QuitThreadOnCounter(&callback_counter));
     } else {
       EXPECT_CALL(client_callback_, OnDone(net::OK, NotNull()))
           .WillOnce(QuitThreadOnCounter(&callback_counter));
       EXPECT_CALL(host_callback_, OnDone(net::OK, NotNull()))
           .WillOnce(QuitThreadOnCounter(&callback_counter));
     }
 
     // Ensure that .Run() does not run unbounded if the callbacks are never
     // called.
     base::Timer shutdown_timer(false, false);
     shutdown_timer.Start(FROM_HERE,
                          TestTimeouts::action_timeout(),
                          base::MessageLoop::QuitClosure());
     message_loop_.Run();
   }
 
-  void OnHostConnected(net::Error error,
+  void OnHostConnected(const std::string& ref_argument,
+                       int error,
                        scoped_ptr<net::StreamSocket> socket) {
+    // Try deleting the authenticator and verify that this doesn't destroy
+    // reference parameters.
+    host_auth_.reset();
+    DCHECK_EQ(ref_argument, "ref argument value");
+
     host_callback_.OnDone(error, socket.get());
     host_socket_ = socket.Pass();
   }
 
-  void OnClientConnected(net::Error error,
-                         scoped_ptr<net::StreamSocket> socket) {
+  void OnClientConnected(int error, scoped_ptr<net::StreamSocket> socket) {
+    client_auth_.reset();
     client_callback_.OnDone(error, socket.get());
     client_socket_ = socket.Pass();
   }
 
   base::MessageLoop message_loop_;
 
   scoped_refptr<RsaKeyPair> key_pair_;
   std::string host_cert_;
   scoped_ptr<FakeSocket> client_fake_socket_;
   scoped_ptr<FakeSocket> host_fake_socket_;
@@ skipping 34 matching lines @@
   host_auth_ = SslHmacChannelAuthenticator::CreateForHost(
       host_cert_, key_pair_, kTestSharedSecret);
 
   RunChannelAuth(true);
 
   ASSERT_TRUE(host_socket_.get() == NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting