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