Cleanup LibjingleTransportFactory

Removed dependency on ChromiumSocketFactory and ChromiumNetworkManager in
LibjingleTransportFactory. It's necessary to compile this code for NaCl.

BUG=276739

Review URL: https://codereview.chromium.org/109393004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@240416 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 57 insertions, 90 deletions

diff --git a/remoting/client/jni/chromoting_jni_instance.cc b/remoting/client/jni/chromoting_jni_instance.cc
index 59b9d38..339cea8 100644
--- a/remoting/client/jni/chromoting_jni_instance.cc
+++ b/remoting/client/jni/chromoting_jni_instance.cc
@@ -12,6 +12,9 @@
 #include "remoting/client/audio_player.h"
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
+#include "remoting/jingle_glue/chromium_port_allocator.h"
+#include "remoting/jingle_glue/chromium_socket_factory.h"
+#include "remoting/jingle_glue/network_settings.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 
@@ -297,14 +300,18 @@ void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
       net::ClientSocketFactory::GetDefaultFactory(),
       jni_runtime_->url_requester(), xmpp_config_));
 
-  network_settings_.reset(new NetworkSettings(
-      NetworkSettings::NAT_TRAVERSAL_ENABLED));
-  scoped_ptr<protocol::TransportFactory> fact(
-      protocol::LibjingleTransportFactory::Create(
-          *network_settings_,
-          jni_runtime_->url_requester()));
+  NetworkSettings network_settings(NetworkSettings::NAT_TRAVERSAL_ENABLED);
 
-  client_->Start(signaling_.get(), fact.Pass());
+  // Use Chrome's network stack to allocate ports for peer-to-peer channels.
+  scoped_ptr<ChromiumPortAllocator> port_allocator(
+      ChromiumPortAllocator::Create(jni_runtime_->url_requester(),
+                                    network_settings));
+
+  scoped_ptr<protocol::TransportFactory> transport_factory(
+      new protocol::LibjingleTransportFactory(
+          port_allocator.PassAs<cricket::HttpPortAllocatorBase>(), false));
+
+  client_->Start(signaling_.get(), transport_factory.Pass());
 }
 
 void ChromotingJniInstance::DisconnectFromHostOnNetworkThread() {
diff --git a/remoting/client/jni/chromoting_jni_instance.h b/remoting/client/jni/chromoting_jni_instance.h
index db409f6..2d80b24 100644
--- a/remoting/client/jni/chromoting_jni_instance.h
+++ b/remoting/client/jni/chromoting_jni_instance.h
@@ -17,7 +17,6 @@
 #include "remoting/client/client_user_interface.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/jni/jni_frame_consumer.h"
-#include "remoting/jingle_glue/network_settings.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_host.h"
@@ -139,7 +138,6 @@ class ChromotingJniInstance
   scoped_ptr<ChromotingClient> client_;
   XmppSignalStrategy::XmppServerConfig xmpp_config_;
   scoped_ptr<XmppSignalStrategy> signaling_;  // Must outlive client_
-  scoped_ptr<NetworkSettings> network_settings_;
 
   // Pass this the user's PIN once we have it. To be assigned and accessed on
   // the UI thread, but must be posted to the network thread to call it.
diff --git a/remoting/host/session_manager_factory.cc b/remoting/host/session_manager_factory.cc
index bbaa8ef..cd5befc 100644
--- a/remoting/host/session_manager_factory.cc
+++ b/remoting/host/session_manager_factory.cc
@@ -5,6 +5,7 @@
 #include "remoting/host/session_manager_factory.h"
 
 #include "remoting/jingle_glue/chromium_port_allocator.h"
+#include "remoting/jingle_glue/chromium_socket_factory.h"
 #include "remoting/jingle_glue/network_settings.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
@@ -16,9 +17,18 @@ scoped_ptr<protocol::SessionManager> CreateHostSessionManager(
     const NetworkSettings& network_settings,
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter) {
+  // Use Chrome's network stack to allocate ports for peer-to-peer channels.
+  scoped_ptr<ChromiumPortAllocator> port_allocator(
+      ChromiumPortAllocator::Create(url_request_context_getter,
+          network_settings));
+
+  bool incoming_only = network_settings.nat_traversal_mode ==
+      NetworkSettings::NAT_TRAVERSAL_DISABLED;
+
   scoped_ptr<protocol::TransportFactory> transport_factory(
-      protocol::LibjingleTransportFactory::Create(network_settings,
-                                                  url_request_context_getter));
+      new protocol::LibjingleTransportFactory(
+          port_allocator.PassAs<cricket::HttpPortAllocatorBase>(),
+          incoming_only));
 
   // Use the Jingle protocol for channel-negotiation signalling between
   // peer TransportFactories.
diff --git a/remoting/protocol/jingle_session_unittest.cc b/remoting/protocol/jingle_session_unittest.cc
index d594cc0..34e09d6 100644
--- a/remoting/protocol/jingle_session_unittest.cc
+++ b/remoting/protocol/jingle_session_unittest.cc
@@ -10,8 +10,11 @@
 #include "base/time/time.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/constants.h"
+#include "remoting/jingle_glue/chromium_port_allocator.h"
 #include "remoting/jingle_glue/fake_signal_strategy.h"
+#include "remoting/jingle_glue/network_settings.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
@@ -137,9 +140,14 @@ class JingleSessionTest : public testing::Test {
 
     EXPECT_CALL(host_server_listener_, OnSessionManagerReady())
         .Times(1);
-    host_server_.reset(new JingleSessionManager(
-        scoped_ptr<TransportFactory>(new LibjingleTransportFactory()),
+
+    NetworkSettings network_settings;
+
+    scoped_ptr<TransportFactory> host_transport(new LibjingleTransportFactory(
+        ChromiumPortAllocator::Create(NULL, network_settings)
+            .PassAs<cricket::HttpPortAllocatorBase>(),
         false));
+    host_server_.reset(new JingleSessionManager(host_transport.Pass(), false));
     host_server_->Init(host_signal_strategy_.get(), &host_server_listener_);
 
     scoped_ptr<AuthenticatorFactory> factory(
@@ -148,8 +156,12 @@ class JingleSessionTest : public testing::Test {
 
     EXPECT_CALL(client_server_listener_, OnSessionManagerReady())
         .Times(1);
-    client_server_.reset(new JingleSessionManager(
-        scoped_ptr<TransportFactory>(new LibjingleTransportFactory()), false));
+    scoped_ptr<TransportFactory> client_transport(new LibjingleTransportFactory(
+        ChromiumPortAllocator::Create(NULL, network_settings)
+            .PassAs<cricket::HttpPortAllocatorBase>(),
+        false));
+    client_server_.reset(
+        new JingleSessionManager(client_transport.Pass(), false));
     client_server_->Init(client_signal_strategy_.get(),
                          &client_server_listener_);
   }
diff --git a/remoting/protocol/libjingle_transport_factory.cc b/remoting/protocol/libjingle_transport_factory.cc
index ac8f0bc..76c3507 100644
--- a/remoting/protocol/libjingle_transport_factory.cc
+++ b/remoting/protocol/libjingle_transport_factory.cc
@@ -13,8 +13,6 @@
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/constants.h"
-#include "remoting/jingle_glue/chromium_port_allocator.h"
-#include "remoting/jingle_glue/chromium_socket_factory.h"
 #include "remoting/jingle_glue/network_settings.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/transport_config.h"
@@ -363,80 +361,38 @@ void LibjingleStreamTransport::NotifyConnectFailed() {
 
 }  // namespace
 
-scoped_ptr<LibjingleTransportFactory> LibjingleTransportFactory::Create(
-    const NetworkSettings& network_settings,
-    const scoped_refptr<net::URLRequestContextGetter>&
-        url_request_context_getter) {
-  // Use Chrome's network stack to allocate ports for peer-to-peer channels.
-  scoped_ptr<ChromiumPortAllocator> port_allocator(
-      ChromiumPortAllocator::Create(url_request_context_getter,
-          network_settings));
-
-  bool incoming_only = network_settings.nat_traversal_mode ==
-      NetworkSettings::NAT_TRAVERSAL_DISABLED;
-
-  // Use libjingle for negotiation of peer-to-peer channels over
-  // NativePortAllocator allocated ports.
-  scoped_ptr<LibjingleTransportFactory> transport_factory(
-      new LibjingleTransportFactory(
-          port_allocator.PassAs<cricket::HttpPortAllocatorBase>(),
-          incoming_only));
-  return transport_factory.Pass();
-}
-
 LibjingleTransportFactory::LibjingleTransportFactory(
     scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator,
     bool incoming_only)
-    : http_port_allocator_(port_allocator.get()),
-      port_allocator_(port_allocator.Pass()),
+    : port_allocator_(port_allocator.Pass()),
       incoming_only_(incoming_only) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 }
 
-LibjingleTransportFactory::LibjingleTransportFactory()
-    : network_manager_(new talk_base::BasicNetworkManager()),
-      socket_factory_(new remoting::ChromiumPacketSocketFactory()),
-      http_port_allocator_(NULL),
-      port_allocator_(new cricket::BasicPortAllocator(
-          network_manager_.get(), socket_factory_.get())),
-      incoming_only_(false) {
-  jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
-  port_allocator_->set_flags(
-      cricket::PORTALLOCATOR_DISABLE_TCP |
-      cricket::PORTALLOCATOR_DISABLE_STUN |
-      cricket::PORTALLOCATOR_DISABLE_RELAY |
-      cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
-      cricket::PORTALLOCATOR_ENABLE_IPV6);
-}
-
 LibjingleTransportFactory::~LibjingleTransportFactory() {
   // This method may be called in response to a libjingle signal, so
   // libjingle objects must be deleted asynchronously.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
   task_runner->DeleteSoon(FROM_HERE, port_allocator_.release());
-  task_runner->DeleteSoon(FROM_HERE, socket_factory_.release());
-  task_runner->DeleteSoon(FROM_HERE, network_manager_.release());
 }
 
 void LibjingleTransportFactory::SetTransportConfig(
     const TransportConfig& config) {
-  if (http_port_allocator_) {
-    std::vector<talk_base::SocketAddress> stun_hosts;
-    talk_base::SocketAddress stun_address;
-    if (stun_address.FromString(config.stun_server)) {
-      stun_hosts.push_back(stun_address);
-      http_port_allocator_->SetStunHosts(stun_hosts);
-    } else {
-      LOG(ERROR) << "Failed to parse stun server address: "
-                 << config.stun_server;
-    }
-
-    std::vector<std::string> relay_hosts;
-    relay_hosts.push_back(config.relay_server);
-    http_port_allocator_->SetRelayHosts(relay_hosts);
-    http_port_allocator_->SetRelayToken(config.relay_token);
+  std::vector<talk_base::SocketAddress> stun_hosts;
+  talk_base::SocketAddress stun_address;
+  if (stun_address.FromString(config.stun_server)) {
+    stun_hosts.push_back(stun_address);
+    port_allocator_->SetStunHosts(stun_hosts);
+  } else {
+    LOG(ERROR) << "Failed to parse stun server address: "
+               << config.stun_server;
   }
+
+  std::vector<std::string> relay_hosts;
+  relay_hosts.push_back(config.relay_server);
+  port_allocator_->SetRelayHosts(relay_hosts);
+  port_allocator_->SetRelayToken(config.relay_token);
 }
 
 scoped_ptr<StreamTransport> LibjingleTransportFactory::CreateStreamTransport() {
diff --git a/remoting/protocol/libjingle_transport_factory.h b/remoting/protocol/libjingle_transport_factory.h
index 5c399bb..dfa0ab1 100644
--- a/remoting/protocol/libjingle_transport_factory.h
+++ b/remoting/protocol/libjingle_transport_factory.h
@@ -29,13 +29,6 @@ namespace protocol {
 
 class LibjingleTransportFactory : public TransportFactory {
  public:
-  // Creates an instance of the class using ChromiumPortAllocator.
-  // Must be called from an IO thread.
-  static scoped_ptr<LibjingleTransportFactory> Create(
-      const NetworkSettings& network_settings,
-      const scoped_refptr<net::URLRequestContextGetter>&
-          url_request_context_getter);
-
   // Need to use cricket::HttpPortAllocatorBase pointer for the
   // |port_allocator|, so that it is possible to configure
   // |port_allocator| with STUN/Relay addresses.
@@ -44,10 +37,6 @@ class LibjingleTransportFactory : public TransportFactory {
       scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator,
       bool incoming_only);
 
-  // Creates BasicNetworkManager, ChromiumPacketSocketFactory and
-  // BasicPortAllocator.
-  LibjingleTransportFactory();
-
   virtual ~LibjingleTransportFactory();
 
   // TransportFactory interface.
@@ -56,12 +45,7 @@ class LibjingleTransportFactory : public TransportFactory {
   virtual scoped_ptr<DatagramTransport> CreateDatagramTransport() OVERRIDE;
 
  private:
-  scoped_ptr<talk_base::NetworkManager> network_manager_;
-  scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
-  // Points to the same port allocator as |port_allocator_| or NULL if
-  // |port_allocator_| is not HttpPortAllocatorBase.
-  cricket::HttpPortAllocatorBase* http_port_allocator_;
-  scoped_ptr<cricket::PortAllocator> port_allocator_;
+  scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator_;
   bool incoming_only_;
 
   DISALLOW_COPY_AND_ASSIGN(LibjingleTransportFactory);