Add P2PDatagramSocket and P2PStreamSocket interfaces.

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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/timer/timer.h"
 #include "crypto/rsa_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_data_directory.h"
 #include "net/test/cert_test_util.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_session.h"

[Wez, 2015/06/22 15:49:07]

Need the p2p_socket.h include here?

[Sergey Ulanov, 2015/07/10 00:49:54]

Done.

 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using testing::_;
 using testing::NotNull;
 using testing::SaveArg;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kTestSharedSecret[] = "1234-1234-5678";
 const char kTestSharedSecretBad[] = "0000-0000-0001";
 
 class MockChannelDoneCallback {
  public:
-  MOCK_METHOD2(OnDone, void(int error, net::StreamSocket* socket));
+  MOCK_METHOD2(OnDone, void(int error, P2PStreamSocket* socket));
 };
 
 ACTION_P(QuitThreadOnCounter, counter) {
   --(*counter);
   EXPECT_GE(*counter, 0);
   if (*counter == 0)
     base::MessageLoop::current()->Quit();
 }
 
 }  // namespace
@@ skipping 58 matching lines @@
     // called.
     base::Timer shutdown_timer(false, false);
     shutdown_timer.Start(FROM_HERE,
                          TestTimeouts::action_timeout(),
                          base::MessageLoop::QuitClosure());
     message_loop_.Run();
   }
 
   void OnHostConnected(const std::string& ref_argument,
                        int error,
-                       scoped_ptr<net::StreamSocket> socket) {
+                       scoped_ptr<P2PStreamSocket> 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(int error, scoped_ptr<net::StreamSocket> socket) {
+  void OnClientConnected(int error, scoped_ptr<P2PStreamSocket> 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<FakeStreamSocket> client_fake_socket_;
   scoped_ptr<FakeStreamSocket> host_fake_socket_;
   scoped_ptr<ChannelAuthenticator> client_auth_;
   scoped_ptr<ChannelAuthenticator> host_auth_;
   MockChannelDoneCallback client_callback_;
   MockChannelDoneCallback host_callback_;
-  scoped_ptr<net::StreamSocket> client_socket_;
-  scoped_ptr<net::StreamSocket> host_socket_;
+  scoped_ptr<P2PStreamSocket> client_socket_;
+  scoped_ptr<P2PStreamSocket> host_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(SslHmacChannelAuthenticatorTest);
 };
 
 // Verify that a channel can be connected using a valid shared secret.
 TEST_F(SslHmacChannelAuthenticatorTest, SuccessfulAuth) {
   client_auth_ = SslHmacChannelAuthenticator::CreateForClient(
       host_cert_, kTestSharedSecret);
   host_auth_ = SslHmacChannelAuthenticator::CreateForHost(
       host_cert_, key_pair_, kTestSharedSecret);
@@ skipping 37 matching lines @@
   host_auth_ = SslHmacChannelAuthenticator::CreateForHost(
       host_cert_, key_pair_, kTestSharedSecret);
 
   RunChannelAuth(net::ERR_CERT_INVALID, net::ERR_CONNECTION_CLOSED);
 
   ASSERT_TRUE(host_socket_.get() == nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting