fake_datagram_socket.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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_DATAGRAM_SOCKET_H_
6#define REMOTING_PROTOCOL_FAKE_DATAGRAM_SOCKET_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 "remoting/protocol/datagram_channel_factory.h"
17
18namespace base {
19class SingleThreadTaskRunner;
20}
21
22namespace remoting {
23namespace protocol {
24
25// FakeDatagramSocket implement net::StreamSocket interface. All data written to
26// FakeDatagramSocket is stored in a buffer returned by written_packets().
27// Read() reads data from another buffer that can be set with
28// AppendInputPacket(). Pending reads are supported, so if there is a pending
29// read AppendInputPacket() calls the read callback.
30//
31// Two fake sockets can be connected to each other using the
32// PairWith() method, e.g.: a->PairWith(b). After this all data
33// written to |a| can be read from |b| and vice versa. Two connected
34// sockets |a| and |b| must be created and used on the same thread.
35class FakeDatagramSocket : public net::Socket {
36 public:
37  FakeDatagramSocket();
38  virtual ~FakeDatagramSocket();
39
40  const std::vector<std::string>& written_packets() const {
41    return written_packets_;
42  }
43
44  void AppendInputPacket(const std::string& data);
45
46  // Current position in the input in number of packets, i.e. number of finished
47  // Read() calls.
48  int input_pos() const { return input_pos_; }
49
50  // Pairs the socket with |peer_socket|. Deleting either of the paired sockets
51  // unpairs them.
52  void PairWith(FakeDatagramSocket* peer_socket);
53
54  base::WeakPtr<FakeDatagramSocket> GetWeakPtr();
55
56  // net::Socket implementation.
57  virtual int Read(net::IOBuffer* buf, int buf_len,
58                   const net::CompletionCallback& callback) OVERRIDE;
59  virtual int Write(net::IOBuffer* buf, int buf_len,
60                    const net::CompletionCallback& callback) OVERRIDE;
61  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
62  virtual int SetSendBufferSize(int32 size) OVERRIDE;
63
64 private:
65  int CopyReadData(net::IOBuffer* buf, int buf_len);
66
67  base::WeakPtr<FakeDatagramSocket> peer_socket_;
68
69  scoped_refptr<net::IOBuffer> read_buffer_;
70  int read_buffer_size_;
71  net::CompletionCallback read_callback_;
72
73  std::vector<std::string> written_packets_;
74  std::vector<std::string> input_packets_;
75  int input_pos_;
76
77  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
78  base::WeakPtrFactory<FakeDatagramSocket> weak_factory_;
79
80  DISALLOW_COPY_AND_ASSIGN(FakeDatagramSocket);
81};
82
83class FakeDatagramChannelFactory : public DatagramChannelFactory {
84 public:
85  FakeDatagramChannelFactory();
86  virtual ~FakeDatagramChannelFactory();
87
88  void set_asynchronous_create(bool asynchronous_create) {
89    asynchronous_create_ = asynchronous_create;
90  }
91
92  void set_fail_create(bool fail_create) { fail_create_ = fail_create; }
93
94  // Pair with |peer_factory|. Once paired the factory will be automatically
95  // pairing created sockets with the sockets with the same name from the peer
96  // factory.
97  void PairWith(FakeDatagramChannelFactory* peer_factory);
98
99  // Can be used to retrieve FakeDatagramSocket created by this factory, e.g. to
100  // feed data into it. The caller doesn't get ownership of the result. Returns
101  // NULL if the socket doesn't exist.
102  FakeDatagramSocket* GetFakeChannel(const std::string& name);
103
104  // DatagramChannelFactory interface.
105  virtual void CreateChannel(const std::string& name,
106                             const ChannelCreatedCallback& callback) OVERRIDE;
107  virtual void CancelChannelCreation(const std::string& name) OVERRIDE;
108
109 private:
110  typedef std::map<std::string, base::WeakPtr<FakeDatagramSocket> > ChannelsMap;
111
112  void NotifyChannelCreated(scoped_ptr<FakeDatagramSocket> owned_socket,
113                            const std::string& name,
114                            const ChannelCreatedCallback& callback);
115
116  base::WeakPtr<FakeDatagramChannelFactory> peer_factory_;
117
118  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
119  bool asynchronous_create_;
120  ChannelsMap channels_;
121
122  bool fail_create_;
123
124  base::WeakPtrFactory<FakeDatagramChannelFactory> weak_factory_;
125
126  DISALLOW_COPY_AND_ASSIGN(FakeDatagramChannelFactory);
127};
128
129}  // namespace protocol
130}  // namespace remoting
131
132#endif  // REMOTING_PROTOCOL_FAKE_DATAGRAM_SOCKET_H_
133