De-Clientize UDPSocket service

mojo/services/network/udp_socket_impl.cc

 // 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.
 
 #include "mojo/services/network/udp_socket_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 16 matching lines @@
 const size_t kMaxWriteSize = 128 * 1024;
 const size_t kMaxPendingSendRequestsUpperbound = 128;
 const size_t kDefaultMaxPendingSendRequests = 32;
 
 }  // namespace
 
 UDPSocketImpl::PendingSendRequest::PendingSendRequest() {}
 
 UDPSocketImpl::PendingSendRequest::~PendingSendRequest() {}
 
-UDPSocketImpl::UDPSocketImpl()
-    : socket_(net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(),
-              nullptr, net::NetLog::Source()),
+UDPSocketImpl::UDPSocketImpl(InterfaceRequest<UDPSocket> request)
+    : binding_(this, request.Pass()),
+      socket_(net::DatagramSocket::DEFAULT_BIND,
+              net::RandIntCallback(),
+              nullptr,
+              net::NetLog::Source()),
       state_(NOT_BOUND_OR_CONNECTED),
       allow_address_reuse_(false),
       remaining_recv_slots_(0),
       max_pending_send_requests_(kDefaultMaxPendingSendRequests) {
 }
 
 UDPSocketImpl::~UDPSocketImpl() {
   STLDeleteElements(&pending_send_requests_);
 }
 
 void UDPSocketImpl::AllowAddressReuse(
     const Callback<void(NetworkErrorPtr)>& callback) {
   if (IsBoundOrConnected()) {
     callback.Run(MakeNetworkError(net::ERR_FAILED));
     return;
   }
 
   allow_address_reuse_ = true;
   callback.Run(MakeNetworkError(net::OK));
 }
 
 void UDPSocketImpl::Bind(
     NetAddressPtr addr,
-    const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
+    const Callback<void(NetworkErrorPtr,
+                        NetAddressPtr,
+                        InterfaceRequest<UDPSocketReceiver>)>& callback) {
   int net_result = net::OK;
   bool opened = false;
 
   do {
     if (IsBoundOrConnected()) {
       net_result = net::ERR_FAILED;
       break;
     }
 
     net::IPEndPoint ip_end_point = addr.To<net::IPEndPoint>();
@@ skipping 17 matching lines @@
     if (net_result != net::OK)
       break;
 
     net::IPEndPoint bound_ip_end_point;
     net_result = socket_.GetLocalAddress(&bound_ip_end_point);
     if (net_result != net::OK)
       break;
 
     state_ = BOUND;
     callback.Run(MakeNetworkError(net_result),
-                 NetAddress::From(bound_ip_end_point));
+                 NetAddress::From(bound_ip_end_point), GetProxy(&receiver_));
 
     if (remaining_recv_slots_ > 0) {
       DCHECK(!recvfrom_buffer_.get());
       DoRecvFrom();
     }
     return;
   } while (false);
 
   DCHECK(net_result != net::OK);
   if (opened)
     socket_.Close();
-  callback.Run(MakeNetworkError(net_result), nullptr);
+  callback.Run(MakeNetworkError(net_result), nullptr, nullptr);
 }
 
 void UDPSocketImpl::Connect(
     NetAddressPtr remote_addr,
-    const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
+    const Callback<void(NetworkErrorPtr,
+                        NetAddressPtr,
+                        InterfaceRequest<UDPSocketReceiver>)>& callback) {
   int net_result = net::OK;
   bool opened = false;
 
   do {
     if (IsBoundOrConnected()) {
       net_result = net::ERR_FAILED;
       break;
     }
 
     net::IPEndPoint ip_end_point = remote_addr.To<net::IPEndPoint>();
@@ skipping 11 matching lines @@
     if (net_result != net::OK)
       break;
 
     net::IPEndPoint local_ip_end_point;
     net_result = socket_.GetLocalAddress(&local_ip_end_point);
     if (net_result != net::OK)
       break;
 
     state_ = CONNECTED;
     callback.Run(MakeNetworkError(net_result),
-                 NetAddress::From(local_ip_end_point));
+                 NetAddress::From(local_ip_end_point), GetProxy(&receiver_));
 
     if (remaining_recv_slots_ > 0) {
       DCHECK(!recvfrom_buffer_.get());
       DoRecvFrom();
     }
     return;
   } while (false);
 
   DCHECK(net_result != net::OK);
   if (opened)
     socket_.Close();
-  callback.Run(MakeNetworkError(net_result), nullptr);
+  callback.Run(MakeNetworkError(net_result), nullptr, nullptr);
 }
 
 void UDPSocketImpl::SetSendBufferSize(
     uint32_t size,
     const Callback<void(NetworkErrorPtr)>& callback) {
   if (!IsBoundOrConnected()) {
     callback.Run(MakeNetworkError(net::ERR_FAILED));
     return;
   }
 
@@ skipping 36 matching lines @@
     pending_send_requests_.resize(max_pending_send_requests_);
     for (auto& discarded_request : discarded_requests) {
       discarded_request->callback.Run(
           MakeNetworkError(net::ERR_INSUFFICIENT_RESOURCES));
       delete discarded_request;
     }
   }
 }
 
 void UDPSocketImpl::ReceiveMore(uint32_t datagram_number) {
+  if (!receiver_)
+    return;
   if (datagram_number == 0)
     return;
   if (std::numeric_limits<size_t>::max() - remaining_recv_slots_ <
           datagram_number) {
     return;
   }
 
   remaining_recv_slots_ += datagram_number;
 
   if (IsBoundOrConnected() && !recvfrom_buffer_.get()) {
@@ skipping 28 matching lines @@
     return;
   }
 
   DCHECK_EQ(0u, pending_send_requests_.size());
 
   DoSendTo(dest_addr.Pass(), data.Pass(), callback);
 }
 
 void UDPSocketImpl::DoRecvFrom() {
   DCHECK(IsBoundOrConnected());
+  DCHECK(receiver_);
   DCHECK(!recvfrom_buffer_.get());
   DCHECK_GT(remaining_recv_slots_, 0u);
 
   recvfrom_buffer_ = new net::IOBuffer(kMaxReadSize);
 
   // It is safe to use base::Unretained(this) because |socket_| is owned by this
   // object. If this object gets destroyed (and so does |socket_|), the callback
   // won't be called.
   int net_result = socket_.RecvFrom(
       recvfrom_buffer_.get(),
@@ skipping 53 matching lines @@
       net_address = NetAddress::From(recvfrom_address_);
 
     std::vector<uint8_t> data(net_result);
     if (net_result > 0)
       memcpy(&data[0], recvfrom_buffer_->data(), net_result);
 
     array.Swap(&data);
   }
   recvfrom_buffer_ = nullptr;
 
-  client()->OnReceived(MakeNetworkError(net_result), net_address.Pass(),
-                       array.Pass());
-
+  receiver_->OnReceived(MakeNetworkError(net_result), net_address.Pass(),
+                        array.Pass());
   DCHECK_GT(remaining_recv_slots_, 0u);
   remaining_recv_slots_--;
   if (remaining_recv_slots_ > 0)
     DoRecvFrom();
 }
 
 void UDPSocketImpl::OnSendToCompleted(
     const Callback<void(NetworkErrorPtr)>& callback,
     int net_result) {
   DCHECK(sendto_buffer_.get());
 
   sendto_buffer_ = nullptr;
 
   callback.Run(MakeNetworkError(net_result));
 
   if (pending_send_requests_.empty())
     return;
 
   scoped_ptr<PendingSendRequest> request(pending_send_requests_.front());
   pending_send_requests_.pop_front();
 
   DoSendTo(request->addr.Pass(), request->data.Pass(), request->callback);
 }
 
 }  // namespace mojo