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
|
// 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/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "net/base/completion_callback.h"
#include "remoting/protocol/p2p_stream_socket.h"
#include "remoting/protocol/stream_channel_factory.h"
namespace base {
class SingleThreadTaskRunner;
}
namespace remoting {
namespace protocol {
// FakeStreamSocket implement P2PStreamSocket 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 P2PStreamSocket {
public:
FakeStreamSocket();
~FakeStreamSocket() override;
// 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 Write() call. Once returned the
// value is automatically reset to net::OK .
void set_next_write_error(int error) { next_write_error_ = error; }
// Appends |data| to the read buffer.
void AppendInputData(const std::string& data);
// Causes Read() to fail with |error| once the read buffer is exhausted. If
// there is a currently pending Read, it is interrupted.
void AppendReadError(int error);
// 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();
// P2PStreamSocket interface.
int Read(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
const net::CompletionCallback& callback) override;
int Write(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
const net::CompletionCallback& callback) override;
private:
void DoAsyncWrite(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
const net::CompletionCallback& callback);
void DoWrite(const scoped_refptr<net::IOBuffer>& buf, int buf_len);
bool async_write_ = false;
bool write_pending_ = false;
int write_limit_ = 0;
int next_write_error_ = 0;
int next_read_error_ = 0;
scoped_refptr<net::IOBuffer> read_buffer_;
int read_buffer_size_ = 0;
net::CompletionCallback read_callback_;
base::WeakPtr<FakeStreamSocket> peer_socket_;
std::string written_data_;
std::string input_data_;
int input_pos_ = 0;
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();
~FakeStreamChannelFactory() override;
void set_asynchronous_create(bool asynchronous_create) {
asynchronous_create_ = asynchronous_create;
}
void set_fail_create(bool fail_create) { fail_create_ = fail_create; }
// Enables asynchronous Write() on created channels.
void set_async_write(bool async_write) { async_write_ = async_write; }
FakeStreamSocket* GetFakeChannel(const std::string& name);
// Pairs the socket with |peer_socket|. Deleting either of the paired sockets
// unpairs them.
void PairWith(FakeStreamChannelFactory* peer_factory);
// ChannelFactory interface.
void CreateChannel(const std::string& name,
const ChannelCreatedCallback& callback) override;
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_ = false;
std::map<std::string, base::WeakPtr<FakeStreamSocket>> channels_;
bool fail_create_ = false;
bool async_write_ = false;
base::WeakPtr<FakeStreamChannelFactory> peer_factory_;
base::WeakPtrFactory<FakeStreamChannelFactory> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(FakeStreamChannelFactory);
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_FAKE_STREAM_SOCKET_H_
|
