Replace libjingle's HttpPortAllocatorSession with Pepper's http client

remoting/jingle_glue/jingle_client.cc

 // Copyright (c) 2011 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/jingle_glue/jingle_client.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "jingle/notifier/communicator/gaia_token_pre_xmpp_auth.h"
+#include "remoting/jingle_glue/http_port_allocator.h"
 #include "remoting/jingle_glue/iq_request.h"
 #include "remoting/jingle_glue/jingle_info_task.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/xmpp_socket_adapter.h"
 #include "third_party/libjingle/source/talk/base/asyncsocket.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/base/ssladapter.h"
 #include "third_party/libjingle/source/talk/p2p/base/sessionmanager.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
-#include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
 #include "third_party/libjingle/source/talk/p2p/client/sessionmanagertask.h"
 #include "third_party/libjingle/source/talk/session/tunnel/tunnelsessionclient.h"
 #include "third_party/libjingle/source/talk/xmpp/prexmppauth.h"
 #include "third_party/libjingle/source/talk/xmpp/saslcookiemechanism.h"
 
 namespace remoting {
 
 // The XmppSignalStrategy encapsulates all the logic to perform the signaling
 // STUN/ICE for jingle via a direct XMPP connection.
 //
@@ skipping 160 matching lines @@
       closed_(false),
       initialized_finished_(false),
       callback_(callback),
       signal_strategy_(signal_strategy) {
 }
 
 JingleClient::JingleClient(JingleThread* thread,
                            SignalStrategy* signal_strategy,
                            talk_base::NetworkManager* network_manager,
                            talk_base::PacketSocketFactory* socket_factory,
+                           PortAllocatorSessionFactory* session_factory,
                            Callback* callback)
     : thread_(thread),
       state_(START),
       initialized_(false),
       closed_(false),
       initialized_finished_(false),
       callback_(callback),
       signal_strategy_(signal_strategy),
       network_manager_(network_manager),
-      socket_factory_(socket_factory) {
+      socket_factory_(socket_factory),
+      port_allocator_session_factory_(session_factory) {
 }
 
 JingleClient::~JingleClient() {
   base::AutoLock auto_lock(state_lock_);
   DCHECK(!initialized_ || closed_);
 }
 
 void JingleClient::Init() {
   {
     base::AutoLock auto_lock(state_lock_);
@@ skipping 12 matching lines @@
     VLOG(1) << "Creating talk_base::NetworkManager.";
     network_manager_.reset(new talk_base::NetworkManager());
   }
   if (!socket_factory_.get()) {
     VLOG(1) << "Creating talk_base::BasicPacketSocketFactory.";
     socket_factory_.reset(new talk_base::BasicPacketSocketFactory(
         talk_base::Thread::Current()));
   }
 
   port_allocator_.reset(
-      new cricket::HttpPortAllocator(network_manager_.get(),
-                                     socket_factory_.get(), "transp2"));
+      new remoting::HttpPortAllocator(
+          network_manager_.get(), socket_factory_.get(),
+          port_allocator_session_factory_.get(), "transp2"));
+
   // TODO(ajwong): The strategy needs a "start" command or something.  Right
   // now, Init() implicitly starts processing events.  Thus, we must have the
   // other fields of JingleClient initialized first, otherwise the state-change
   // may occur and callback into class before we're done initializing.
   signal_strategy_->Init(this);
   signal_strategy_->ConfigureAllocator(
       port_allocator_.get(),
       NewRunnableMethod(this, &JingleClient::DoStartSession));
 }
 
@@ skipping 86 matching lines @@
     }
   }
 }
 
 void JingleClient::OnJidChange(const std::string& full_jid) {
   base::AutoLock auto_lock(jid_lock_);
   full_jid_ = full_jid;
 }
 
 }  // namespace remoting