Revert of Use standard ICE in Chromoting.

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 26 matching lines @@
 namespace net {
 class Socket;
 class StreamSocket;
 }  // namespace net
 
 namespace remoting {
 namespace protocol {
 
 class ChannelAuthenticator;
 
-enum class TransportRole {
-  SERVER,
-  CLIENT,
-};
-
 struct TransportRoute {
   enum RouteType {
     DIRECT,
     STUN,
     RELAY,
   };
 
   // Helper method to get string representation of the type.
   static std::string GetTypeString(RouteType type);
 
   TransportRoute();
   ~TransportRoute();
 
   RouteType type;
   net::IPEndPoint remote_address;
   net::IPEndPoint local_address;
 };
 
 class Transport : public base::NonThreadSafe {
  public:
   class EventHandler {
    public:
     EventHandler() {};
     virtual ~EventHandler() {};
 
-    // Called to pass ICE credentials to the session. Used only for STANDARD
-    // version of ICE, see SetIceVersion().
-    virtual void OnTransportIceCredentials(Transport* transport,
-                                           const std::string& ufrag,
-                                           const std::string& password) = 0;
-
     // Called when the transport generates a new candidate that needs
     // to be passed to the AddRemoteCandidate() method on the remote
     // end of the connection.
     virtual void OnTransportCandidate(Transport* transport,
                                       const cricket::Candidate& candidate) = 0;
 
     // Called when transport route changes. Can be called even before
     // the transport is connected.
     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;
 
-  // Sets remote ICE credentials.
-  virtual void SetRemoteCredentials(const std::string& ufrag,
-                                    const std::string& password) = 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;
 
-  // Sets ICE version for the transport.
-  //
-  // TODO(sergeyu): Remove this when support for legacy ICE is removed.
-  // crbug.com/473758
-  virtual void SetUseStandardIce(bool use_standard_ice) {}
-
  private:
   DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
 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;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransportFactory);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_TRANSPORT_H_