Add static Create method to LibjingleTransportFactory

remoting/protocol/session_manager_factory.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/host/session_manager_factory.h"
+#include "remoting/protocol/session_manager_factory.h"
 
-#include "net/url_request/url_request_context_getter.h"
-#include "remoting/host/host_port_allocator.h"
-#include "remoting/host/network_settings.h"
+#include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
-#include "remoting/protocol/jingle_session_manager.h"
+#include "remoting/protocol/native_port_allocator.h"
+#include "remoting/protocol/network_settings.h"
+#include "remoting/protocol/session_manager.h"
 
 namespace remoting {
 
-scoped_ptr<protocol::SessionManager> CreateHostSessionManager(
+namespace protocol {
+
+scoped_ptr<protocol::TransportFactory> CreateTransportFactory(

[Sergey Ulanov, 2013/06/20 19:37:53]

This function doesn't belong to this file. It would be better to add a static
Create() method in LibjingleTransportFactory.

     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<HostPortAllocator> port_allocator(
-      HostPortAllocator::Create(url_request_context_getter,
+  scoped_ptr<NativePortAllocator> port_allocator(
+      NativePortAllocator::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
-  // HostPortAllocator allocated ports.
+  // NativePortAllocator allocated ports.
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
           port_allocator.PassAs<cricket::HttpPortAllocatorBase>(),
           incoming_only));
+  return transport_factory.Pass();
+}
+
+scoped_ptr<protocol::SessionManager> CreateNativeSessionManager(

[Sergey Ulanov, 2013/06/20 19:37:53]

This function doesn't do much, so I don't think we need it at all.
I suggest that you keep this file in the host directory, keep this function as
CreateHostSessionManager(), but move LibjingleTransportFactory creation to a
static LibjingleTransportFactory::Create() as I suggested above. For the client
side you don't really need to worry about nat traversal (it's always enabled),
so session manager creation becomes simpler:

scoped_ptr<protocol::SessionManager> session_manager(
    new protocol::JingleSessionManager(
        CreateTransportFactory(network_settings, url_request_context_getter),
        true);

+    const NetworkSettings& network_settings,
+    const scoped_refptr<net::URLRequestContextGetter>&
+        url_request_context_getter) {
+  scoped_ptr<protocol::TransportFactory> transport_factory(
+      CreateTransportFactory(network_settings,
+      url_request_context_getter));

[Sergey Ulanov, 2013/06/20 19:37:53]

this argument should be aligned with the first argument on the previous line.

 
   // Use the Jingle protocol for channel-negotiation signalling between
   // peer TransportFactories.
   bool fetch_stun_relay_info = network_settings.nat_traversal_mode ==
       NetworkSettings::NAT_TRAVERSAL_ENABLED;
 
   scoped_ptr<protocol::JingleSessionManager> session_manager(
       new protocol::JingleSessionManager(
           transport_factory.Pass(), fetch_stun_relay_info));
   return session_manager.PassAs<protocol::SessionManager>();
 }
 
+} // namespace protocol
+
 } // namespace remoting