Move ownership of Transport out of Session.

remoting/protocol/ice_transport_unittest.cc

 // Copyright 2015 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/ice_transport.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 #include "remoting/protocol/stream_channel_factory.h"
 #include "remoting/protocol/transport_context.h"
-#include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using testing::_;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
@@ skipping 13 matching lines @@
   EXPECT_GE(*counter, 0);
   if (*counter == 0)
     run_loop->Quit();
 }
 
 class MockChannelCreatedCallback {
  public:
   MOCK_METHOD1(OnDone, void(P2PStreamSocket* socket));
 };
 
-class TestTransportEventHandler : public Transport::EventHandler {
+class TestTransportEventHandler : public IceTransport::EventHandler {
  public:
-  typedef base::Callback<void(scoped_ptr<buzz::XmlElement> message)>
-      TransportInfoCallback;
   typedef base::Callback<void(ErrorCode error)> ErrorCallback;
 
   TestTransportEventHandler() {}
   ~TestTransportEventHandler() {}
 
-  // Both callback must be set before the test handler is passed to a Transport
-  // object.
-  void set_transport_info_callback(const TransportInfoCallback& callback) {
-    transport_info_callback_ = callback;
-  }
-  void set_connected_callback(const base::Closure& callback) {
-    connected_callback_ = callback;
-  }
   void set_error_callback(const ErrorCallback& callback) {
     error_callback_ = callback;
   }
 
-  // Transport::EventHandler interface.
-  void OnOutgoingTransportInfo(scoped_ptr<buzz::XmlElement> message) override {
-    transport_info_callback_.Run(std::move(message));
-  }
-  void OnTransportRouteChange(const std::string& channel_name,
+  // IceTransport::EventHandler interface.
+  void OnIceTransportRouteChange(const std::string& channel_name,
                               const TransportRoute& route) override {}
-  void OnTransportConnected() override {
-    connected_callback_.Run();
-  }
-  void OnTransportError(ErrorCode error) override {
+  void OnIceTransportError(ErrorCode error) override {
     error_callback_.Run(error);
   }
 
  private:
-  TransportInfoCallback transport_info_callback_;
-  base::Closure connected_callback_;
   ErrorCallback error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTransportEventHandler);
 };
 
 }  // namespace
 
 class IceTransportTest : public testing::Test {
  public:
   IceTransportTest() {
@@ skipping 20 matching lines @@
   }
 
   void DeliverTransportInfo(scoped_ptr<IceTransport>* target_transport,
                             scoped_ptr<buzz::XmlElement> transport_info) {
     ASSERT_TRUE(target_transport);
     EXPECT_TRUE(
         (*target_transport)->ProcessTransportInfo(transport_info.get()));
   }
 
   void InitializeConnection() {
-    host_transport_.reset(new IceTransport(new TransportContext(
-        signal_strategy_.get(),
-        make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
-        network_settings_, TransportRole::SERVER)));
+    host_transport_.reset(
+        new IceTransport(TransportContext::ForTests(TransportRole::SERVER),
+                         &host_event_handler_));
     if (!host_authenticator_) {
       host_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, true));
     }
 
-    client_transport_.reset(new IceTransport(new TransportContext(
-        signal_strategy_.get(),
-        make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
-        network_settings_, TransportRole::CLIENT)));
+    client_transport_.reset(
+        new IceTransport(TransportContext::ForTests(TransportRole::CLIENT),
+                         &client_event_handler_));
     if (!client_authenticator_) {
       client_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::CLIENT, 0, FakeAuthenticator::ACCEPT, true));
     }
 
-    // Connect signaling between the two IceTransport objects.
-    host_event_handler_.set_transport_info_callback(
-        base::Bind(&IceTransportTest::ProcessTransportInfo,
-                   base::Unretained(this), &client_transport_));
-    client_event_handler_.set_transport_info_callback(
-        base::Bind(&IceTransportTest::ProcessTransportInfo,
-                   base::Unretained(this), &host_transport_));
-
-    host_event_handler_.set_connected_callback(base::Bind(&base::DoNothing));
     host_event_handler_.set_error_callback(base::Bind(
         &IceTransportTest::OnTransportError, base::Unretained(this)));
-
-    client_event_handler_.set_connected_callback(base::Bind(&base::DoNothing));
     client_event_handler_.set_error_callback(base::Bind(
         &IceTransportTest::OnTransportError, base::Unretained(this)));
 
-    host_transport_->Start(&host_event_handler_, host_authenticator_.get());
-    client_transport_->Start(&client_event_handler_,
-                             client_authenticator_.get());
+    // Start both transports.
+    host_transport_->Start(
+        host_authenticator_.get(),
+        base::Bind(&IceTransportTest::ProcessTransportInfo,
+                   base::Unretained(this), &client_transport_));
+    client_transport_->Start(
+        client_authenticator_.get(),
+        base::Bind(&IceTransportTest::ProcessTransportInfo,
+                   base::Unretained(this), &host_transport_));
   }
 
   void WaitUntilConnected() {
     run_loop_.reset(new base::RunLoop());
 
     int counter = 2;
     EXPECT_CALL(client_channel_callback_, OnDone(_))
         .WillOnce(QuitRunLoopOnCounter(run_loop_.get(), &counter));
     EXPECT_CALL(host_channel_callback_, OnDone(_))
         .WillOnce(QuitRunLoopOnCounter(run_loop_.get(), &counter));
@@ skipping 18 matching lines @@
     error_ = error;
     run_loop_->Quit();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   NetworkSettings network_settings_;
 
-  scoped_ptr<FakeSignalStrategy> signal_strategy_;
-
   base::TimeDelta transport_info_delay_;
 
   scoped_ptr<IceTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
   scoped_ptr<FakeAuthenticator> host_authenticator_;
 
   scoped_ptr<IceTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
   scoped_ptr<FakeAuthenticator> client_authenticator_;
 
@@ skipping 130 matching lines @@
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
 
 }  // namespace protocol
 }  // namespace remoting