| // 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. |
| |
| #ifndef REMOTING_PROTOCOL_TRANSPORT_H_ |
| #define REMOTING_PROTOCOL_TRANSPORT_H_ |
| |
| #include <string> |
| |
| #include "base/basictypes.h" |
| #include "base/callback_forward.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/threading/non_thread_safe.h" |
| #include "net/base/ip_endpoint.h" |
| #include "remoting/protocol/errors.h" |
| |
| namespace cricket { |
| class Candidate; |
| } // namespace cricket |
| |
| namespace buzz { |
| class XmlElement; |
| } // namespace buzz |
| |
| namespace webrtc { |
| class PeerConnectionInterface; |
| } // namespace webrtc |
| |
| namespace remoting { |
| namespace protocol { |
| |
| class Authenticator; |
| class DatagramChannelFactory; |
| class P2PDatagramSocket; |
| class StreamChannelFactory; |
| class WebrtcTransport; |
| |
| 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; |
| }; |
| |
| // Transport represents a P2P connection that consists of one or more |
| // channels. |
| class Transport { |
| public: |
| class EventHandler { |
| public: |
| // Called to send a transport-info message. |
| virtual void OnOutgoingTransportInfo( |
| scoped_ptr<buzz::XmlElement> message) = 0; |
| |
| // Called when transport route changes. |
| virtual void OnTransportRouteChange(const std::string& channel_name, |
| const TransportRoute& route) = 0; |
| |
| // Called when the transport is connected. |
| virtual void OnTransportConnected() = 0; |
| |
| // Called when there is an error connecting the session. |
| virtual void OnTransportError(ErrorCode error) = 0; |
| }; |
| |
| Transport() {} |
| virtual ~Transport() {} |
| |
| // Starts transport session. Both parameters must outlive Transport. |
| virtual void Start(EventHandler* event_handler, |
| Authenticator* authenticator) = 0; |
| |
| // Called to process incoming transport message. Returns false if |
| // |transport_info| is in invalid format. |
| virtual bool ProcessTransportInfo(buzz::XmlElement* transport_info) = 0; |
| |
| // Channel factory for the session that creates stream channels. |
| virtual StreamChannelFactory* GetStreamChannelFactory() = 0; |
| |
| // Returns a factory that creates multiplexed channels over a single stream |
| // channel. |
| virtual StreamChannelFactory* GetMultiplexedChannelFactory() = 0; |
| |
| // Returns the transport as WebrtcTransport or nullptr if this is not a |
| // WebrtcTransport. |
| // |
| // TODO(sergeyu): Move creation and ownership of Transport objects to the |
| // Connection classes. That way the Connection classes will be able to ensure |
| // that correct transport implementation is used for the connection and this |
| // method will not be necessary. |
| virtual WebrtcTransport* AsWebrtcTransport(); |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(Transport); |
| }; |
| |
| class TransportFactory { |
| public: |
| TransportFactory() { } |
| virtual ~TransportFactory() { } |
| |
| // Creates a new Transport. The factory must outlive the session. |
| virtual scoped_ptr<Transport> CreateTransport() = 0; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(TransportFactory); |
| }; |
| |
| } // namespace protocol |
| } // namespace remoting |
| |
| #endif // REMOTING_PROTOCOL_TRANSPORT_H_ |