Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/protocol/jingle_session_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/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 69 matching lines @@
 
 class MockSessionEventHandler : public Session::EventHandler {
  public:
   MOCK_METHOD1(OnSessionStateChange, void(Session::State));
   MOCK_METHOD2(OnSessionRouteChange, void(const std::string& channel_name,
                                           const TransportRoute& route));
 };
 
 class MockChannelCreatedCallback {
  public:
-  MOCK_METHOD1(OnDone, void(net::StreamSocket* socket));
+  MOCK_METHOD1(OnDone, void(P2PStreamSocket* socket));
 };
 
 }  // namespace
 
 class JingleSessionTest : public testing::Test {
  public:
   JingleSessionTest() {
     message_loop_.reset(new base::MessageLoopForIO());
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   }
 
   // Helper method that handles OnIncomingSession().
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_.reset(session);
     host_session_->SetEventHandler(&host_session_event_handler_);
 
     session->set_config(standard_ice_ ? SessionConfig::ForTest()
                                       : SessionConfig::WithLegacyIceForTest());
   }
 
   void DeleteSession() {
     host_session_.reset();
   }
 
-  void OnClientChannelCreated(scoped_ptr<net::StreamSocket> socket) {
+  void OnClientChannelCreated(scoped_ptr<P2PStreamSocket> socket) {
     client_channel_callback_.OnDone(socket.get());
     client_socket_ = socket.Pass();
   }
 
-  void OnHostChannelCreated(scoped_ptr<net::StreamSocket> socket) {
+  void OnHostChannelCreated(scoped_ptr<P2PStreamSocket> socket) {
     host_channel_callback_.OnDone(socket.get());
     host_socket_ = socket.Pass();
   }
 
  protected:
   void SetUp() override {}
 
   void TearDown() override {
     CloseSessions();
     CloseSessionManager();
@@ skipping 170 matching lines @@
   MockSessionManagerListener client_server_listener_;
 
   scoped_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
   scoped_ptr<Session> client_session_;
   MockSessionEventHandler client_session_event_handler_;
 
   MockChannelCreatedCallback client_channel_callback_;
   MockChannelCreatedCallback host_channel_callback_;
 
-  scoped_ptr<net::StreamSocket> client_socket_;
-  scoped_ptr<net::StreamSocket> host_socket_;
+  scoped_ptr<P2PStreamSocket> client_socket_;
+  scoped_ptr<P2PStreamSocket> host_socket_;
 };
 
 
 // Verify that we can create and destroy session managers without a
 // connection.
 TEST_F(JingleSessionTest, CreateAndDestoy) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 }
 
 // Verify that an incoming session can be rejected, and that the
@@ skipping 242 matching lines @@
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, 1);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
 }  // namespace protocol
 }  // namespace remoting