OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "network/public/cpp/udp_socket_wrapper.h" | |
6 | |
7 #include <assert.h> | 5 #include <assert.h> |
| 6 #include <utility> |
8 | 7 |
9 #include "mojo/public/cpp/environment/logging.h" | 8 #include "mojo/public/cpp/environment/logging.h" |
| 9 #include "network/public/cpp/udp_socket_wrapper.h" |
10 | 10 |
11 namespace mojo { | 11 namespace mojo { |
12 namespace { | 12 namespace { |
13 | 13 |
14 const uint32_t kDefaultReceiveQueueSlots = 32; | 14 const uint32_t kDefaultReceiveQueueSlots = 32; |
15 | 15 |
16 } // namespace | 16 } // namespace |
17 | 17 |
18 UDPSocketWrapper::NegotiateCallbackHandler::NegotiateCallbackHandler( | 18 UDPSocketWrapper::NegotiateCallbackHandler::NegotiateCallbackHandler( |
19 UDPSocketWrapper* delegate) | 19 UDPSocketWrapper* delegate) |
(...skipping 10 matching lines...) Expand all Loading... |
30 UDPSocketWrapper::SendCallbackHandler::SendCallbackHandler( | 30 UDPSocketWrapper::SendCallbackHandler::SendCallbackHandler( |
31 UDPSocketWrapper* delegate, | 31 UDPSocketWrapper* delegate, |
32 const ErrorCallback& forward_callback) | 32 const ErrorCallback& forward_callback) |
33 : delegate_(delegate), | 33 : delegate_(delegate), |
34 forward_callback_(forward_callback) { | 34 forward_callback_(forward_callback) { |
35 } | 35 } |
36 | 36 |
37 UDPSocketWrapper::SendCallbackHandler::~SendCallbackHandler() {} | 37 UDPSocketWrapper::SendCallbackHandler::~SendCallbackHandler() {} |
38 | 38 |
39 void UDPSocketWrapper::SendCallbackHandler::Run(NetworkErrorPtr result) const { | 39 void UDPSocketWrapper::SendCallbackHandler::Run(NetworkErrorPtr result) const { |
40 delegate_->OnSendToCompleted(result.Pass(), forward_callback_); | 40 delegate_->OnSendToCompleted(std::move(result), forward_callback_); |
41 } | 41 } |
42 | 42 |
43 UDPSocketWrapper::ReceiverBindingCallback::ReceiverBindingCallback( | 43 UDPSocketWrapper::ReceiverBindingCallback::ReceiverBindingCallback( |
44 UDPSocketWrapper* delegate, | 44 UDPSocketWrapper* delegate, |
45 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& wrapper_callback) | 45 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& wrapper_callback) |
46 : delegate_(delegate), wrapper_callback_(wrapper_callback) { | 46 : delegate_(delegate), wrapper_callback_(wrapper_callback) { |
47 } | 47 } |
48 | 48 |
49 UDPSocketWrapper::ReceiverBindingCallback::~ReceiverBindingCallback() { | 49 UDPSocketWrapper::ReceiverBindingCallback::~ReceiverBindingCallback() { |
50 } | 50 } |
51 | 51 |
52 void UDPSocketWrapper::ReceiverBindingCallback::Run( | 52 void UDPSocketWrapper::ReceiverBindingCallback::Run( |
53 NetworkErrorPtr result, | 53 NetworkErrorPtr result, |
54 NetAddressPtr addr, | 54 NetAddressPtr addr, |
55 InterfaceRequest<UDPSocketReceiver> request) const { | 55 InterfaceRequest<UDPSocketReceiver> request) const { |
56 delegate_->StartReceivingData(request.Pass()); | 56 delegate_->StartReceivingData(std::move(request)); |
57 wrapper_callback_.Run(result.Pass(), addr.Pass()); | 57 wrapper_callback_.Run(std::move(result), std::move(addr)); |
58 } | 58 } |
59 | 59 |
60 UDPSocketWrapper::ReceivedData::ReceivedData() {} | 60 UDPSocketWrapper::ReceivedData::ReceivedData() {} |
61 UDPSocketWrapper::ReceivedData::~ReceivedData() {} | 61 UDPSocketWrapper::ReceivedData::~ReceivedData() {} |
62 | 62 |
63 UDPSocketWrapper::SendRequest::SendRequest() {} | 63 UDPSocketWrapper::SendRequest::SendRequest() {} |
64 UDPSocketWrapper::SendRequest::~SendRequest() {} | 64 UDPSocketWrapper::SendRequest::~SendRequest() {} |
65 | 65 |
66 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket) | 66 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket) |
67 : binding_(this), | 67 : binding_(this), |
68 socket_(socket.Pass()), | 68 socket_(std::move(socket)), |
69 max_receive_queue_size_(kDefaultReceiveQueueSlots), | 69 max_receive_queue_size_(kDefaultReceiveQueueSlots), |
70 max_pending_sends_(1), | 70 max_pending_sends_(1), |
71 current_pending_sends_(0) { | 71 current_pending_sends_(0) { |
72 Initialize(0); | 72 Initialize(0); |
73 } | 73 } |
74 | 74 |
75 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket, | 75 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket, |
76 uint32_t receive_queue_slots, | 76 uint32_t receive_queue_slots, |
77 uint32_t requested_max_pending_sends) | 77 uint32_t requested_max_pending_sends) |
78 : binding_(this), | 78 : binding_(this), |
79 socket_(socket.Pass()), | 79 socket_(std::move(socket)), |
80 max_receive_queue_size_(receive_queue_slots), | 80 max_receive_queue_size_(receive_queue_slots), |
81 max_pending_sends_(1), | 81 max_pending_sends_(1), |
82 current_pending_sends_(0) { | 82 current_pending_sends_(0) { |
83 Initialize(requested_max_pending_sends); | 83 Initialize(requested_max_pending_sends); |
84 } | 84 } |
85 | 85 |
86 UDPSocketWrapper::~UDPSocketWrapper() { | 86 UDPSocketWrapper::~UDPSocketWrapper() { |
87 while (!receive_queue_.empty()) { | 87 while (!receive_queue_.empty()) { |
88 delete receive_queue_.front(); | 88 delete receive_queue_.front(); |
89 receive_queue_.pop(); | 89 receive_queue_.pop(); |
90 } | 90 } |
91 while (!send_requests_.empty()) { | 91 while (!send_requests_.empty()) { |
92 delete send_requests_.front(); | 92 delete send_requests_.front(); |
93 send_requests_.pop(); | 93 send_requests_.pop(); |
94 } | 94 } |
95 } | 95 } |
96 | 96 |
97 void UDPSocketWrapper::AllowAddressReuse(const ErrorCallback& callback) { | 97 void UDPSocketWrapper::AllowAddressReuse(const ErrorCallback& callback) { |
98 socket_->AllowAddressReuse(callback); | 98 socket_->AllowAddressReuse(callback); |
99 } | 99 } |
100 | 100 |
101 void UDPSocketWrapper::Bind( | 101 void UDPSocketWrapper::Bind( |
102 NetAddressPtr addr, | 102 NetAddressPtr addr, |
103 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) { | 103 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) { |
104 socket_->Bind( | 104 socket_->Bind( |
105 addr.Pass(), | 105 std::move(addr), |
106 BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>( | 106 BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>( |
107 new ReceiverBindingCallback(this, callback)))); | 107 new ReceiverBindingCallback(this, callback)))); |
108 } | 108 } |
109 | 109 |
110 void UDPSocketWrapper::Connect( | 110 void UDPSocketWrapper::Connect( |
111 NetAddressPtr remote_addr, | 111 NetAddressPtr remote_addr, |
112 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) { | 112 const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) { |
113 socket_->Connect( | 113 socket_->Connect( |
114 remote_addr.Pass(), | 114 std::move(remote_addr), |
115 BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>( | 115 BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>( |
116 new ReceiverBindingCallback(this, callback)))); | 116 new ReceiverBindingCallback(this, callback)))); |
117 } | 117 } |
118 | 118 |
119 void UDPSocketWrapper::SetSendBufferSize(uint32_t size, | 119 void UDPSocketWrapper::SetSendBufferSize(uint32_t size, |
120 const ErrorCallback& callback) { | 120 const ErrorCallback& callback) { |
121 socket_->SetSendBufferSize(size, callback); | 121 socket_->SetSendBufferSize(size, callback); |
122 } | 122 } |
123 | 123 |
124 void UDPSocketWrapper::SetReceiveBufferSize(uint32_t size, | 124 void UDPSocketWrapper::SetReceiveBufferSize(uint32_t size, |
125 const ErrorCallback& callback) { | 125 const ErrorCallback& callback) { |
126 socket_->SetReceiveBufferSize(size, callback); | 126 socket_->SetReceiveBufferSize(size, callback); |
127 } | 127 } |
128 | 128 |
129 bool UDPSocketWrapper::ReceiveFrom(const ReceiveCallback& callback) { | 129 bool UDPSocketWrapper::ReceiveFrom(const ReceiveCallback& callback) { |
130 if (receive_queue_.empty()) { | 130 if (receive_queue_.empty()) { |
131 receive_requests_.push(callback); | 131 receive_requests_.push(callback); |
132 return false; | 132 return false; |
133 } | 133 } |
134 | 134 |
135 ReceivedData* data = receive_queue_.front(); | 135 ReceivedData* data = receive_queue_.front(); |
136 receive_queue_.pop(); | 136 receive_queue_.pop(); |
137 socket_->ReceiveMore(1); | 137 socket_->ReceiveMore(1); |
138 callback.Run(data->result.Pass(), data->src_addr.Pass(), data->data.Pass()); | 138 callback.Run(std::move(data->result), std::move(data->src_addr), |
| 139 std::move(data->data)); |
139 delete data; | 140 delete data; |
140 return true; | 141 return true; |
141 } | 142 } |
142 | 143 |
143 void UDPSocketWrapper::SendTo(NetAddressPtr dest_addr, | 144 void UDPSocketWrapper::SendTo(NetAddressPtr dest_addr, |
144 Array<uint8_t> data, | 145 Array<uint8_t> data, |
145 const ErrorCallback& callback) { | 146 const ErrorCallback& callback) { |
146 if (current_pending_sends_ >= max_pending_sends_) { | 147 if (current_pending_sends_ >= max_pending_sends_) { |
147 SendRequest* request = new SendRequest(); | 148 SendRequest* request = new SendRequest(); |
148 request->dest_addr = dest_addr.Pass(); | 149 request->dest_addr = std::move(dest_addr); |
149 request->data = data.Pass(); | 150 request->data = std::move(data); |
150 request->callback = callback; | 151 request->callback = callback; |
151 send_requests_.push(request); | 152 send_requests_.push(request); |
152 return; | 153 return; |
153 } | 154 } |
154 | 155 |
155 MOJO_DCHECK(send_requests_.empty()); | 156 MOJO_DCHECK(send_requests_.empty()); |
156 current_pending_sends_++; | 157 current_pending_sends_++; |
157 socket_->SendTo(dest_addr.Pass(), data.Pass(), | 158 socket_->SendTo(std::move(dest_addr), std::move(data), |
158 ErrorCallback(static_cast<ErrorCallback::Runnable*>( | 159 ErrorCallback(static_cast<ErrorCallback::Runnable*>( |
159 new SendCallbackHandler(this, callback)))); | 160 new SendCallbackHandler(this, callback)))); |
160 } | 161 } |
161 | 162 |
162 void UDPSocketWrapper::OnReceived(NetworkErrorPtr result, | 163 void UDPSocketWrapper::OnReceived(NetworkErrorPtr result, |
163 NetAddressPtr src_addr, | 164 NetAddressPtr src_addr, |
164 Array<uint8_t> data) { | 165 Array<uint8_t> data) { |
165 if (!receive_requests_.empty()) { | 166 if (!receive_requests_.empty()) { |
166 // The cache should be empty if there are user requests waiting for data. | 167 // The cache should be empty if there are user requests waiting for data. |
167 MOJO_DCHECK(receive_queue_.empty()); | 168 MOJO_DCHECK(receive_queue_.empty()); |
168 | 169 |
169 socket_->ReceiveMore(1); | 170 socket_->ReceiveMore(1); |
170 | 171 |
171 ReceiveCallback callback = receive_requests_.front(); | 172 ReceiveCallback callback = receive_requests_.front(); |
172 receive_requests_.pop(); | 173 receive_requests_.pop(); |
173 | 174 |
174 callback.Run(result.Pass(), src_addr.Pass(), data.Pass()); | 175 callback.Run(std::move(result), std::move(src_addr), std::move(data)); |
175 return; | 176 return; |
176 } | 177 } |
177 | 178 |
178 MOJO_DCHECK(receive_queue_.size() < max_receive_queue_size_); | 179 MOJO_DCHECK(receive_queue_.size() < max_receive_queue_size_); |
179 ReceivedData* received_data = new ReceivedData(); | 180 ReceivedData* received_data = new ReceivedData(); |
180 received_data->result = result.Pass(); | 181 received_data->result = std::move(result); |
181 received_data->src_addr = src_addr.Pass(); | 182 received_data->src_addr = std::move(src_addr); |
182 received_data->data = data.Pass(); | 183 received_data->data = std::move(data); |
183 receive_queue_.push(received_data); | 184 receive_queue_.push(received_data); |
184 } | 185 } |
185 | 186 |
186 void UDPSocketWrapper::Initialize(uint32_t requested_max_pending_sends) { | 187 void UDPSocketWrapper::Initialize(uint32_t requested_max_pending_sends) { |
187 socket_->NegotiateMaxPendingSendRequests( | 188 socket_->NegotiateMaxPendingSendRequests( |
188 requested_max_pending_sends, | 189 requested_max_pending_sends, |
189 Callback<void(uint32_t)>( | 190 Callback<void(uint32_t)>( |
190 static_cast< Callback<void(uint32_t)>::Runnable*>( | 191 static_cast< Callback<void(uint32_t)>::Runnable*>( |
191 new NegotiateCallbackHandler(this)))); | 192 new NegotiateCallbackHandler(this)))); |
192 } | 193 } |
(...skipping 11 matching lines...) Expand all Loading... |
204 | 205 |
205 while (ProcessNextSendRequest()); | 206 while (ProcessNextSendRequest()); |
206 } | 207 } |
207 | 208 |
208 void UDPSocketWrapper::OnSendToCompleted( | 209 void UDPSocketWrapper::OnSendToCompleted( |
209 NetworkErrorPtr result, | 210 NetworkErrorPtr result, |
210 const ErrorCallback& forward_callback) { | 211 const ErrorCallback& forward_callback) { |
211 current_pending_sends_--; | 212 current_pending_sends_--; |
212 ProcessNextSendRequest(); | 213 ProcessNextSendRequest(); |
213 | 214 |
214 forward_callback.Run(result.Pass()); | 215 forward_callback.Run(std::move(result)); |
215 } | 216 } |
216 | 217 |
217 bool UDPSocketWrapper::ProcessNextSendRequest() { | 218 bool UDPSocketWrapper::ProcessNextSendRequest() { |
218 if (current_pending_sends_ >= max_pending_sends_ || send_requests_.empty()) | 219 if (current_pending_sends_ >= max_pending_sends_ || send_requests_.empty()) |
219 return false; | 220 return false; |
220 | 221 |
221 SendRequest* request = send_requests_.front(); | 222 SendRequest* request = send_requests_.front(); |
222 send_requests_.pop(); | 223 send_requests_.pop(); |
223 | 224 |
224 current_pending_sends_++; | 225 current_pending_sends_++; |
225 | 226 |
226 socket_->SendTo( | 227 socket_->SendTo(std::move(request->dest_addr), std::move(request->data), |
227 request->dest_addr.Pass(), request->data.Pass(), | 228 ErrorCallback(static_cast<ErrorCallback::Runnable*>( |
228 ErrorCallback(static_cast<ErrorCallback::Runnable*>( | 229 new SendCallbackHandler(this, request->callback)))); |
229 new SendCallbackHandler(this, request->callback)))); | |
230 | 230 |
231 delete request; | 231 delete request; |
232 | 232 |
233 return true; | 233 return true; |
234 } | 234 } |
235 | 235 |
236 void UDPSocketWrapper::StartReceivingData( | 236 void UDPSocketWrapper::StartReceivingData( |
237 InterfaceRequest<UDPSocketReceiver> request) { | 237 InterfaceRequest<UDPSocketReceiver> request) { |
238 binding_.Bind(request.Pass()); | 238 binding_.Bind(std::move(request)); |
239 socket_->ReceiveMore(max_receive_queue_size_); | 239 socket_->ReceiveMore(max_receive_queue_size_); |
240 } | 240 } |
241 | 241 |
242 } // namespace mojo | 242 } // namespace mojo |
OLD | NEW |