Add TransportContext class.

remoting/test/test_chromoting_client.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/test/test_chromoting_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/host_stub.h"
-#include "remoting/protocol/ice_transport_factory.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/third_party_client_authenticator.h"
+#include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 #include "remoting/test/connection_setup_info.h"
 #include "remoting/test/test_video_renderer.h"
 
 namespace {
 const char kXmppHostName[] = "talk.google.com";
 const int kXmppPortNumber = 5222;
 
 // Used as the TokenFetcherCallback for App Remoting sessions.
 void FetchThirdPartyToken(
@@ skipping 78 matching lines @@
   xmpp_server_config.auth_token = connection_setup_info.access_token;
 
   // Set up the signal strategy.  This must outlive the client object.
   signal_strategy_.reset(
       new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                              request_context_getter, xmpp_server_config));
 
   protocol::NetworkSettings network_settings(
       protocol::NetworkSettings::NAT_TRAVERSAL_FULL);
 
-  scoped_ptr<protocol::ChromiumPortAllocator> port_allocator(
-      protocol::ChromiumPortAllocator::Create(request_context_getter,
-                                              network_settings));
+  scoped_ptr<protocol::ChromiumPortAllocatorFactory> port_allocator_factory(
+      new protocol::ChromiumPortAllocatorFactory(request_context_getter));
 
-  scoped_ptr<protocol::TransportFactory> transport_factory(
-      new protocol::IceTransportFactory(
-          signal_strategy_.get(), port_allocator.Pass(), network_settings,
-          protocol::TransportRole::CLIENT));
+  scoped_refptr<protocol::TransportContext> transport_context(
+      new protocol::TransportContext(
+          signal_strategy_.get(), port_allocator_factory.Pass(),
+          network_settings, protocol::TransportRole::CLIENT));
 
   scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
       token_fetcher(new TokenFetcherProxy(
           base::Bind(&FetchThirdPartyToken,
                      connection_setup_info.authorization_code,
                      connection_setup_info.shared_secret),
           connection_setup_info.public_key));
 
   protocol::FetchSecretCallback fetch_secret_callback;
   if (!connection_setup_info.pin.empty()) {
     fetch_secret_callback = base::Bind(&FetchSecret, connection_setup_info.pin);
   }
 
   scoped_ptr<protocol::Authenticator> authenticator(
       new protocol::NegotiatingClientAuthenticator(
           connection_setup_info.pairing_id,
           connection_setup_info.shared_secret,
           connection_setup_info.host_id,
           fetch_secret_callback,
           token_fetcher.Pass(),
           connection_setup_info.auth_methods));
 
   chromoting_client_->Start(
-      signal_strategy_.get(), authenticator.Pass(), transport_factory.Pass(),
+      signal_strategy_.get(), authenticator.Pass(), transport_context,
       connection_setup_info.host_jid, connection_setup_info.capabilities);
 }
 
 void TestChromotingClient::EndConnection() {
   // Clearing out the client will close the connection.
   chromoting_client_.reset();
 
   // The signal strategy object must outlive the client so destroy it next.
   signal_strategy_.reset();
 
@@ skipping 105 matching lines @@
   VLOG(1) << "TestChromotingClient::InjectClipboardEvent() Called";
 }
 
 void TestChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   VLOG(1) << "TestChromotingClient::SetCursorShape() Called";
 }
 
 }  // namespace test
 }  // namespace remoting