1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef REMOTING_PROTOCOL_FAKE_SESSION_H_ 6 #define REMOTING_PROTOCOL_FAKE_SESSION_H_ 7 8 #include <map> 9 #include <string> 10 #include <vector> 11 12 #include "base/memory/scoped_ptr.h" 13 #include "base/memory/weak_ptr.h" 14 #include "net/base/completion_callback.h" 15 #include "net/socket/socket.h" 16 #include "net/socket/stream_socket.h" 17 #include "remoting/protocol/channel_factory.h" 18 #include "remoting/protocol/session.h" 19 20 namespace base { 21 class MessageLoop; 22 } 23 24 namespace remoting { 25 namespace protocol { 26 27 extern const char kTestJid[]; 28 29 // FakeSocket implement net::Socket interface for FakeConnection. All data 30 // written to FakeSocket is stored in a buffer returned by written_data(). 31 // Read() reads data from another buffer that can be set with AppendInputData(). 32 // Pending reads are supported, so if there is a pending read AppendInputData() 33 // calls the read callback. 34 // 35 // Two fake sockets can be connected to each other using the 36 // PairWith() method, e.g.: a->PairWith(b). After this all data 37 // written to |a| can be read from |b| and vica versa. Two connected 38 // sockets |a| and |b| must be created and used on the same thread. 39 class FakeSocket : public net::StreamSocket { 40 public: 41 FakeSocket(); 42 virtual ~FakeSocket(); 43 44 const std::string& written_data() const { return written_data_; } 45 46 void set_write_limit(int write_limit) { write_limit_ = write_limit; } 47 void set_async_write(bool async_write) { async_write_ = async_write; } 48 void set_next_write_error(int error) { next_write_error_ = error; } 49 void set_next_read_error(int error) { next_read_error_ = error; } 50 void AppendInputData(const std::vector<char>& data); 51 void PairWith(FakeSocket* peer_socket); 52 int input_pos() const { return input_pos_; } 53 bool read_pending() const { return read_pending_; } 54 55 // net::Socket implementation. 56 virtual int Read(net::IOBuffer* buf, int buf_len, 57 const net::CompletionCallback& callback) OVERRIDE; 58 virtual int Write(net::IOBuffer* buf, int buf_len, 59 const net::CompletionCallback& callback) OVERRIDE; 60 61 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE; 62 virtual bool SetSendBufferSize(int32 size) OVERRIDE; 63 64 // net::StreamSocket interface. 65 virtual int Connect(const net::CompletionCallback& callback) OVERRIDE; 66 virtual void Disconnect() OVERRIDE; 67 virtual bool IsConnected() const OVERRIDE; 68 virtual bool IsConnectedAndIdle() const OVERRIDE; 69 virtual int GetPeerAddress(net::IPEndPoint* address) const OVERRIDE; 70 virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE; 71 virtual const net::BoundNetLog& NetLog() const OVERRIDE; 72 virtual void SetSubresourceSpeculation() OVERRIDE; 73 virtual void SetOmniboxSpeculation() OVERRIDE; 74 virtual bool WasEverUsed() const OVERRIDE; 75 virtual bool UsingTCPFastOpen() const OVERRIDE; 76 virtual bool WasNpnNegotiated() const OVERRIDE; 77 virtual net::NextProto GetNegotiatedProtocol() const OVERRIDE; 78 virtual bool GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE; 79 80 private: 81 void DoAsyncWrite(scoped_refptr<net::IOBuffer> buf, int buf_len, 82 const net::CompletionCallback& callback); 83 void DoWrite(net::IOBuffer* buf, int buf_len); 84 85 bool async_write_; 86 bool write_pending_; 87 int write_limit_; 88 int next_write_error_; 89 90 int next_read_error_; 91 bool read_pending_; 92 scoped_refptr<net::IOBuffer> read_buffer_; 93 int read_buffer_size_; 94 net::CompletionCallback read_callback_; 95 base::WeakPtr<FakeSocket> peer_socket_; 96 97 std::string written_data_; 98 std::string input_data_; 99 int input_pos_; 100 101 net::BoundNetLog net_log_; 102 103 base::MessageLoop* message_loop_; 104 base::WeakPtrFactory<FakeSocket> weak_factory_; 105 106 DISALLOW_COPY_AND_ASSIGN(FakeSocket); 107 }; 108 109 // FakeUdpSocket is similar to FakeSocket but behaves as UDP socket. All written 110 // packets are stored separetely in written_packets(). AppendInputPacket() adds 111 // one packet that will be returned by Read(). 112 class FakeUdpSocket : public net::Socket { 113 public: 114 FakeUdpSocket(); 115 virtual ~FakeUdpSocket(); 116 117 const std::vector<std::string>& written_packets() const { 118 return written_packets_; 119 } 120 121 void AppendInputPacket(const char* data, int data_size); 122 int input_pos() const { return input_pos_; } 123 124 // net::Socket implementation. 125 virtual int Read(net::IOBuffer* buf, int buf_len, 126 const net::CompletionCallback& callback) OVERRIDE; 127 virtual int Write(net::IOBuffer* buf, int buf_len, 128 const net::CompletionCallback& callback) OVERRIDE; 129 130 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE; 131 virtual bool SetSendBufferSize(int32 size) OVERRIDE; 132 133 private: 134 bool read_pending_; 135 scoped_refptr<net::IOBuffer> read_buffer_; 136 int read_buffer_size_; 137 net::CompletionCallback read_callback_; 138 139 std::vector<std::string> written_packets_; 140 std::vector<std::string> input_packets_; 141 int input_pos_; 142 143 base::MessageLoop* message_loop_; 144 145 DISALLOW_COPY_AND_ASSIGN(FakeUdpSocket); 146 }; 147 148 // FakeSession is a dummy protocol::Session that uses FakeSocket for all 149 // channels. 150 class FakeSession : public Session, 151 public ChannelFactory { 152 public: 153 FakeSession(); 154 virtual ~FakeSession(); 155 156 EventHandler* event_handler() { return event_handler_; } 157 158 void set_async_creation(bool async_creation) { 159 async_creation_ = async_creation; 160 } 161 162 void set_error(ErrorCode error) { error_ = error; } 163 164 bool is_closed() const { return closed_; } 165 166 FakeSocket* GetStreamChannel(const std::string& name); 167 FakeUdpSocket* GetDatagramChannel(const std::string& name); 168 169 // Session interface. 170 virtual void SetEventHandler(EventHandler* event_handler) OVERRIDE; 171 virtual ErrorCode error() OVERRIDE; 172 virtual const std::string& jid() OVERRIDE; 173 virtual const CandidateSessionConfig* candidate_config() OVERRIDE; 174 virtual const SessionConfig& config() OVERRIDE; 175 virtual void set_config(const SessionConfig& config) OVERRIDE; 176 virtual ChannelFactory* GetTransportChannelFactory() OVERRIDE; 177 virtual ChannelFactory* GetMultiplexedChannelFactory() OVERRIDE; 178 virtual void Close() OVERRIDE; 179 180 // ChannelFactory interface. 181 virtual void CreateStreamChannel( 182 const std::string& name, 183 const StreamChannelCallback& callback) OVERRIDE; 184 virtual void CreateDatagramChannel( 185 const std::string& name, 186 const DatagramChannelCallback& callback) OVERRIDE; 187 virtual void CancelChannelCreation(const std::string& name) OVERRIDE; 188 189 public: 190 void NotifyStreamChannelCallback( 191 const std::string& name, 192 const StreamChannelCallback& callback); 193 void NotifyDatagramChannelCallback( 194 const std::string& name, 195 const DatagramChannelCallback& callback); 196 197 EventHandler* event_handler_; 198 scoped_ptr<const CandidateSessionConfig> candidate_config_; 199 SessionConfig config_; 200 base::MessageLoop* message_loop_; 201 202 bool async_creation_; 203 204 std::map<std::string, FakeSocket*> stream_channels_; 205 std::map<std::string, FakeUdpSocket*> datagram_channels_; 206 207 std::string jid_; 208 209 ErrorCode error_; 210 bool closed_; 211 212 base::WeakPtrFactory<FakeSession> weak_factory_; 213 214 DISALLOW_COPY_AND_ASSIGN(FakeSession); 215 }; 216 217 } // namespace protocol 218 } // namespace remoting 219 220 #endif // REMOTING_PROTOCOL_FAKE_SESSION_H_ 221
