blob: 62818e40cdb8d79fab5c32a05a12fd280211c8a5 (
plain)
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
|
// Copyright (c) 2010 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_SESSION_H_
#define REMOTING_PROTOCOL_FAKE_SESSION_H_
#include <string>
#include <vector>
#include "base/scoped_ptr.h"
#include "net/socket/socket.h"
#include "remoting/protocol/session.h"
namespace remoting {
namespace protocol {
extern const char kTestJid[];
// FakeSocket implement net::Socket interface for FakeConnection. All data
// written to FakeSocket 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.
class FakeSocket : public net::Socket {
public:
FakeSocket();
virtual ~FakeSocket();
const std::string& written_data() { return written_data_; }
void AppendInputData(char* data, int data_size);
int input_pos() { return input_pos_; }
// net::Socket interface.
virtual int Read(net::IOBuffer* buf, int buf_len,
net::CompletionCallback* callback);
virtual int Write(net::IOBuffer* buf, int buf_len,
net::CompletionCallback* callback);
virtual bool SetReceiveBufferSize(int32 size);
virtual bool SetSendBufferSize(int32 size);
private:
bool read_pending_;
scoped_refptr<net::IOBuffer> read_buffer_;
int read_buffer_size_;
net::CompletionCallback* read_callback_;
std::string written_data_;
std::string input_data_;
int input_pos_;
};
// FakeUdpSocket is similar to FakeSocket but behaves as UDP socket. All written
// packets are stored separetely in written_packets(). AppendInputPacket() adds
// one packet that will be returned by Read().
class FakeUdpSocket : public net::Socket {
public:
FakeUdpSocket();
virtual ~FakeUdpSocket();
const std::vector<std::string>& written_packets() {
return written_packets_;
}
void AppendInputPacket(char* data, int data_size);
int input_pos() { return input_pos_; }
// net::Socket interface.
virtual int Read(net::IOBuffer* buf, int buf_len,
net::CompletionCallback* callback);
virtual int Write(net::IOBuffer* buf, int buf_len,
net::CompletionCallback* callback);
virtual bool SetReceiveBufferSize(int32 size);
virtual bool SetSendBufferSize(int32 size);
private:
bool read_pending_;
scoped_refptr<net::IOBuffer> read_buffer_;
int read_buffer_size_;
net::CompletionCallback* read_callback_;
std::vector<std::string> written_packets_;
std::vector<std::string> input_packets_;
int input_pos_;
};
// FakeSession is a dummy protocol::Session that uses FakeSocket for all
// channels.
class FakeSession : public Session {
public:
FakeSession();
virtual ~FakeSession();
StateChangeCallback* state_change_callback() { return callback_.get(); }
void set_message_loop(MessageLoop* message_loop) {
message_loop_ = message_loop;
}
bool is_closed() { return closed_; }
virtual void SetStateChangeCallback(StateChangeCallback* callback);
virtual FakeSocket* control_channel();
virtual FakeSocket* event_channel();
virtual FakeSocket* video_channel();
virtual FakeUdpSocket* video_rtp_channel();
virtual FakeUdpSocket* video_rtcp_channel();
virtual const std::string& jid();
virtual MessageLoop* message_loop();
virtual const CandidateSessionConfig* candidate_config();
virtual const SessionConfig* config();
virtual void set_config(const SessionConfig* config);
virtual const std::string& initiator_token();
virtual void set_initiator_token(const std::string& initiator_token);
virtual const std::string& receiver_token();
virtual void set_receiver_token(const std::string& receiver_token);
virtual void Close(Task* closed_task);
public:
scoped_ptr<StateChangeCallback> callback_;
scoped_ptr<const CandidateSessionConfig> candidate_config_;
scoped_ptr<const SessionConfig> config_;
MessageLoop* message_loop_;
FakeSocket control_channel_;
FakeSocket event_channel_;
FakeSocket video_channel_;
FakeUdpSocket video_rtp_channel_;
FakeUdpSocket video_rtcp_channel_;
std::string initiator_token_;
std::string receiver_token_;
std::string jid_;
bool closed_;
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_FAKE_SESSION_H_
|
