Replace libjingle's HttpPortAllocatorSession with Pepper's http client

remoting/protocol/connection_to_host.h

 // Copyright (c) 2010 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.
 
 #ifndef REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_
 #define REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_
 
 #include <string>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "remoting/jingle_glue/jingle_client.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/message_reader.h"
 #include "remoting/protocol/session.h"
 #include "remoting/protocol/session_manager.h"
 
 class MessageLoop;
 
 namespace remoting {
 
 class JingleThread;
+class PortAllocatorSessionFactory;
 class VideoPacket;
 
 namespace protocol {
 
 class ClientMessageDispatcher;
 class ClientStub;
 class SessionConfig;
 class VideoReader;
 class VideoStub;
 
@@ skipping 12 matching lines @@
     // Called when the network connection has failed.
     virtual void OnConnectionFailed(ConnectionToHost* conn) = 0;
   };
 
   // Takes ownership of |network_manager| and |socket_factory|. Both
   // |network_manager| and |socket_factory| may be set to NULL.
   //
   // TODO(sergeyu): Constructor shouldn't need thread here.
   ConnectionToHost(JingleThread* thread,
                    talk_base::NetworkManager* network_manager,
-                   talk_base::PacketSocketFactory* socket_factory);
+                   talk_base::PacketSocketFactory* socket_factory,
+                   PortAllocatorSessionFactory* session_factory);
   virtual ~ConnectionToHost();
 
   // TODO(ajwong): We need to generalize this API.
   virtual void Connect(const std::string& username,
                        const std::string& auth_token,
                        const std::string& host_jid,
                        HostEventCallback* event_callback,
                        ClientStub* client_stub,
                        VideoStub* video_stub);
   virtual void Disconnect();
@@ skipping 36 matching lines @@
 
   // Initially false, this is set to true once the client has authenticated
   // properly. When this is false, many messages to the host (like input events)
   // will be suppressed.
   bool client_authenticated_;
 
   JingleThread* thread_;
 
   scoped_ptr<talk_base::NetworkManager> network_manager_;
   scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
+  scoped_ptr<PortAllocatorSessionFactory> port_allocator_session_factory_;
 
   scoped_ptr<SignalStrategy> signal_strategy_;
   scoped_refptr<JingleClient> jingle_client_;
   scoped_refptr<SessionManager> session_manager_;
   scoped_refptr<Session> session_;
 
   scoped_ptr<VideoReader> video_reader_;
 
   HostEventCallback* event_callback_;
 
@@ skipping 25 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectionToHost);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::protocol::ConnectionToHost);
 
 #endif  // REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_