1// Copyright 2014 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_STREAM_SOCKET_H_
6#define REMOTING_PROTOCOL_FAKE_STREAM_SOCKET_H_
7
8#include <map>
9#include <string>
10
11#include "base/memory/scoped_ptr.h"
12#include "base/memory/weak_ptr.h"
13#include "net/base/completion_callback.h"
14#include "net/socket/stream_socket.h"
15#include "remoting/protocol/stream_channel_factory.h"
16
17namespace base {
18class SingleThreadTaskRunner;
19}
20
21namespace remoting {
22namespace protocol {
23
24// FakeStreamSocket implement net::StreamSocket interface. All data written to
25// FakeStreamSocket is stored in a buffer returned by written_data(). Read()
26// reads data from another buffer that can be set with AppendInputData().
27// Pending reads are supported, so if there is a pending read AppendInputData()
28// calls the read callback.
29//
30// Two fake sockets can be connected to each other using the
31// PairWith() method, e.g.: a->PairWith(b). After this all data
32// written to |a| can be read from |b| and vice versa. Two connected
33// sockets |a| and |b| must be created and used on the same thread.
34class FakeStreamSocket : public net::StreamSocket {
35 public:
36  FakeStreamSocket();
37  virtual ~FakeStreamSocket();
38
39  // Returns all data written to the socket.
40  const std::string& written_data() const { return written_data_; }
41
42  // Sets maximum number of bytes written by each Write() call.
43  void set_write_limit(int write_limit) { write_limit_ = write_limit; }
44
45  // Enables asynchronous Write().
46  void set_async_write(bool async_write) { async_write_ = async_write; }
47
48  // Set error codes for the next Read() and Write() calls. Once returned the
49  // values are automatically reset to net::OK .
50  void set_next_read_error(int error) { next_read_error_ = error; }
51  void set_next_write_error(int error) { next_write_error_ = error; }
52
53  // Appends |data| to the read buffer.
54  void AppendInputData(const std::string& data);
55
56  // Pairs the socket with |peer_socket|. Deleting either of the paired sockets
57  // unpairs them.
58  void PairWith(FakeStreamSocket* peer_socket);
59
60  // Current input position in bytes.
61  int input_pos() const { return input_pos_; }
62
63  // True if a Read() call is currently pending.
64  bool read_pending() const { return !read_callback_.is_null(); }
65
66  base::WeakPtr<FakeStreamSocket> GetWeakPtr();
67
68  // net::Socket implementation.
69  virtual int Read(net::IOBuffer* buf, int buf_len,
70                   const net::CompletionCallback& callback) OVERRIDE;
71  virtual int Write(net::IOBuffer* buf, int buf_len,
72                    const net::CompletionCallback& callback) OVERRIDE;
73  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
74  virtual int SetSendBufferSize(int32 size) OVERRIDE;
75
76  // net::StreamSocket interface.
77  virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
78  virtual void Disconnect() OVERRIDE;
79  virtual bool IsConnected() const OVERRIDE;
80  virtual bool IsConnectedAndIdle() const OVERRIDE;
81  virtual int GetPeerAddress(net::IPEndPoint* address) const OVERRIDE;
82  virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE;
83  virtual const net::BoundNetLog& NetLog() const OVERRIDE;
84  virtual void SetSubresourceSpeculation() OVERRIDE;
85  virtual void SetOmniboxSpeculation() OVERRIDE;
86  virtual bool WasEverUsed() const OVERRIDE;
87  virtual bool UsingTCPFastOpen() const OVERRIDE;
88  virtual bool WasNpnNegotiated() const OVERRIDE;
89  virtual net::NextProto GetNegotiatedProtocol() const OVERRIDE;
90  virtual bool GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
91
92 private:
93  void DoAsyncWrite(scoped_refptr<net::IOBuffer> buf, int buf_len,
94                    const net::CompletionCallback& callback);
95  void DoWrite(net::IOBuffer* buf, int buf_len);
96
97  bool async_write_;
98  bool write_pending_;
99  int write_limit_;
100  int next_write_error_;
101
102  int next_read_error_;
103  scoped_refptr<net::IOBuffer> read_buffer_;
104  int read_buffer_size_;
105  net::CompletionCallback read_callback_;
106  base::WeakPtr<FakeStreamSocket> peer_socket_;
107
108  std::string written_data_;
109  std::string input_data_;
110  int input_pos_;
111
112  net::BoundNetLog net_log_;
113
114  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
115  base::WeakPtrFactory<FakeStreamSocket> weak_factory_;
116
117  DISALLOW_COPY_AND_ASSIGN(FakeStreamSocket);
118};
119
120// StreamChannelFactory that creates FakeStreamSocket.
121class FakeStreamChannelFactory : public StreamChannelFactory {
122 public:
123  FakeStreamChannelFactory();
124  virtual ~FakeStreamChannelFactory();
125
126  void set_asynchronous_create(bool asynchronous_create) {
127    asynchronous_create_ = asynchronous_create;
128  }
129
130  void set_fail_create(bool fail_create) { fail_create_ = fail_create; }
131
132  FakeStreamSocket* GetFakeChannel(const std::string& name);
133
134  // ChannelFactory interface.
135  virtual void CreateChannel(const std::string& name,
136                             const ChannelCreatedCallback& callback) OVERRIDE;
137  virtual void CancelChannelCreation(const std::string& name) OVERRIDE;
138
139 private:
140  void NotifyChannelCreated(scoped_ptr<FakeStreamSocket> owned_channel,
141                            const std::string& name,
142                            const ChannelCreatedCallback& callback);
143
144  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
145  bool asynchronous_create_;
146  std::map<std::string, base::WeakPtr<FakeStreamSocket> > channels_;
147
148  bool fail_create_;
149
150  base::WeakPtrFactory<FakeStreamChannelFactory> weak_factory_;
151
152  DISALLOW_COPY_AND_ASSIGN(FakeStreamChannelFactory);
153};
154
155}  // namespace protocol
156}  // namespace remoting
157
158#endif  // REMOTING_PROTOCOL_FAKE_STREAM_SOCKET_H_
159