OLD | NEW |
| (Empty) |
1 // Copyright 2013 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 #include <algorithm> | |
6 | |
7 #include "net/base/net_errors.h" | |
8 #include "net/dns/mock_mdns_socket_factory.h" | |
9 | |
10 using testing::_; | |
11 using testing::Invoke; | |
12 | |
13 namespace net { | |
14 | |
15 MockMDnsDatagramServerSocket::MockMDnsDatagramServerSocket( | |
16 AddressFamily address_family) { | |
17 local_address_ = GetMDnsIPEndPoint(address_family); | |
18 } | |
19 | |
20 MockMDnsDatagramServerSocket::~MockMDnsDatagramServerSocket() { | |
21 } | |
22 | |
23 int MockMDnsDatagramServerSocket::SendTo(IOBuffer* buf, int buf_len, | |
24 const IPEndPoint& address, | |
25 const CompletionCallback& callback) { | |
26 return SendToInternal(std::string(buf->data(), buf_len), address.ToString(), | |
27 callback); | |
28 } | |
29 | |
30 int MockMDnsDatagramServerSocket::GetLocalAddress(IPEndPoint* address) const { | |
31 *address = local_address_; | |
32 return OK; | |
33 } | |
34 | |
35 void MockMDnsDatagramServerSocket::SetResponsePacket( | |
36 std::string response_packet) { | |
37 response_packet_ = response_packet; | |
38 } | |
39 | |
40 int MockMDnsDatagramServerSocket::HandleRecvNow( | |
41 IOBuffer* buffer, int size, IPEndPoint* address, | |
42 const CompletionCallback& callback) { | |
43 int size_returned = | |
44 std::min(response_packet_.size(), static_cast<size_t>(size)); | |
45 memcpy(buffer->data(), response_packet_.data(), size_returned); | |
46 return size_returned; | |
47 } | |
48 | |
49 int MockMDnsDatagramServerSocket::HandleRecvLater( | |
50 IOBuffer* buffer, int size, IPEndPoint* address, | |
51 const CompletionCallback& callback) { | |
52 int rv = HandleRecvNow(buffer, size, address, callback); | |
53 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, rv)); | |
54 return ERR_IO_PENDING; | |
55 } | |
56 | |
57 MockMDnsSocketFactory::MockMDnsSocketFactory() { | |
58 } | |
59 | |
60 MockMDnsSocketFactory::~MockMDnsSocketFactory() { | |
61 } | |
62 | |
63 void MockMDnsSocketFactory::CreateSockets( | |
64 ScopedVector<DatagramServerSocket>* sockets) { | |
65 CreateSocket(ADDRESS_FAMILY_IPV4, sockets); | |
66 CreateSocket(ADDRESS_FAMILY_IPV6, sockets); | |
67 } | |
68 | |
69 void MockMDnsSocketFactory::CreateSocket( | |
70 AddressFamily address_family, | |
71 ScopedVector<DatagramServerSocket>* sockets) { | |
72 scoped_ptr<testing::NiceMock<MockMDnsDatagramServerSocket> > new_socket( | |
73 new testing::NiceMock<MockMDnsDatagramServerSocket>(address_family)); | |
74 | |
75 ON_CALL(*new_socket, SendToInternal(_, _, _)) | |
76 .WillByDefault(Invoke( | |
77 this, | |
78 &MockMDnsSocketFactory::SendToInternal)); | |
79 | |
80 ON_CALL(*new_socket, RecvFrom(_, _, _, _)) | |
81 .WillByDefault(Invoke( | |
82 this, | |
83 &MockMDnsSocketFactory::RecvFromInternal)); | |
84 | |
85 sockets->push_back(new_socket.release()); | |
86 } | |
87 | |
88 void MockMDnsSocketFactory::SimulateReceive(const uint8* packet, int size) { | |
89 DCHECK(recv_buffer_size_ >= size); | |
90 DCHECK(recv_buffer_.get()); | |
91 DCHECK(!recv_callback_.is_null()); | |
92 | |
93 memcpy(recv_buffer_->data(), packet, size); | |
94 CompletionCallback recv_callback = recv_callback_; | |
95 recv_callback_.Reset(); | |
96 recv_callback.Run(size); | |
97 } | |
98 | |
99 int MockMDnsSocketFactory::RecvFromInternal( | |
100 IOBuffer* buffer, int size, | |
101 IPEndPoint* address, | |
102 const CompletionCallback& callback) { | |
103 recv_buffer_ = buffer; | |
104 recv_buffer_size_ = size; | |
105 recv_callback_ = callback; | |
106 return ERR_IO_PENDING; | |
107 } | |
108 | |
109 int MockMDnsSocketFactory::SendToInternal( | |
110 const std::string& packet, const std::string& address, | |
111 const CompletionCallback& callback) { | |
112 OnSendTo(packet); | |
113 return packet.size(); | |
114 } | |
115 | |
116 } // namespace net | |
OLD | NEW |