Add TransportContext class.

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 {
 
@@ skipping 91 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() {
-    port_allocator_ = ChromiumPortAllocator::Create(nullptr, network_settings_);
-
-    host_transport_.reset(new IceTransport(
-        port_allocator_.get(), network_settings_, TransportRole::SERVER));
-    host_transport_->GetCanStartClosure().Run();
-
+    host_transport_.reset(new IceTransport(new TransportContext(
+        signal_strategy_.get(),
+        make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
+        network_settings_, TransportRole::SERVER)));
     if (!host_authenticator_) {
       host_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, true));
     }
 
-    client_transport_.reset(new IceTransport(
-        port_allocator_.get(), network_settings_, TransportRole::CLIENT));
-    client_transport_->GetCanStartClosure().Run();
+    client_transport_.reset(new IceTransport(new TransportContext(
+        signal_strategy_.get(),
+        make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
+        network_settings_, TransportRole::CLIENT)));
     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(
@@ skipping 46 matching lines @@
  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<cricket::PortAllocator> port_allocator_;
-
-  // scoped_ptr<IceTransportFactory> host_transport_factory_;
   scoped_ptr<IceTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
   scoped_ptr<FakeAuthenticator> host_authenticator_;
 
-  // scoped_ptr<IceTransportFactory> client_transport_factory_;
   scoped_ptr<IceTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
   scoped_ptr<FakeAuthenticator> client_authenticator_;
 
   MockChannelCreatedCallback client_channel_callback_;
   MockChannelCreatedCallback host_channel_callback_;
 
   scoped_ptr<P2PStreamSocket> client_socket_;
   scoped_ptr<P2PStreamSocket> host_socket_;
 
@@ skipping 124 matching lines @@
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
 
 }  // namespace protocol
 }  // namespace remoting