Revert of Move PseudoTCP and channel auth out of LibjingleTransportFactory.

remoting/protocol/transport.h

 // 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.
 //
 // This file defines the interface for peer-to-peer transport. There
 // are two types of transport: StreamTransport and DatagramTransport.
 // They must both be created using TransportFactory instances and they
 // provide the same interface, except that one should be used for
 // reliable stream connection and the other one for unreliable
 // datagram connection. The Transport interface itself doesn't provide
@@ skipping 69 matching lines @@
     virtual void OnTransportRouteChange(Transport* transport,
                                         const TransportRoute& route) = 0;
 
     // Called when when the transport has failed to connect or reconnect.
     virtual void OnTransportFailed(Transport* transport) = 0;
 
     // Called when the transport is about to be deleted.
     virtual void OnTransportDeleted(Transport* transport) = 0;
   };
 
-  typedef base::Callback<void(scoped_ptr<net::Socket>)> ConnectedCallback;
-
   Transport() {}
   virtual ~Transport() {}
 
-  // Connects the transport and calls the |callback| after that.
-  virtual void Connect(const std::string& name,
-                       Transport::EventHandler* event_handler,
-                       const ConnectedCallback& callback) = 0;
+  // Intialize the transport with the specified parameters.
+  // |authenticator| is used to secure and authenticate the connection.
+  virtual void Initialize(const std::string& name,
+                          Transport::EventHandler* event_handler,
+                          scoped_ptr<ChannelAuthenticator> authenticator) = 0;
 
   // Adds |candidate| received from the peer.
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) = 0;
 
   // Name of the channel. It is used to identify the channel and
   // disambiguate candidates it generates from candidates generated by
   // parallel connections.
   virtual const std::string& name() const = 0;
 
   // Returns true if the channel is already connected.
   virtual bool is_connected() const = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
+class StreamTransport : public Transport {
+ public:
+  typedef base::Callback<void(scoped_ptr<net::StreamSocket>)> ConnectedCallback;
+
+  StreamTransport() { }
+  virtual ~StreamTransport() { }
+
+  virtual void Connect(const ConnectedCallback& callback) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StreamTransport);
+};
+
+class DatagramTransport : public Transport {
+ public:
+  typedef base::Callback<void(scoped_ptr<net::Socket>)> ConnectedCallback;
+
+  DatagramTransport() { }
+  virtual ~DatagramTransport() { }
+
+  virtual void Connect(const ConnectedCallback& callback) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DatagramTransport);
+};
+
 class TransportFactory {
  public:
   TransportFactory() { }
   virtual ~TransportFactory() { }
 
   // Called to notify transport factory that a new transport might be created
   // soon, e.g. when a new session is being created. Implementation may use it
   // to start asynchronous preparation, e.g. fetch a new relay token if
   // necessary while the session is being authenticated.
   virtual void PrepareTokens() = 0;
 
-  virtual scoped_ptr<Transport> CreateTransport() = 0;
+  virtual scoped_ptr<StreamTransport> CreateStreamTransport() = 0;
+  virtual scoped_ptr<DatagramTransport> CreateDatagramTransport() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransportFactory);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_TRANSPORT_H_