De-Clientize UDPSocket service

mojo/services/network/public/cpp/udp_socket_wrapper.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 "network/public/cpp/udp_socket_wrapper.h"
 
 #include <assert.h>
 
 #include "third_party/mojo/src/mojo/public/cpp/environment/logging.h"
 
@@ skipping 22 matching lines @@
     : delegate_(delegate),
       forward_callback_(forward_callback) {
 }
 
 UDPSocketWrapper::SendCallbackHandler::~SendCallbackHandler() {}
 
 void UDPSocketWrapper::SendCallbackHandler::Run(NetworkErrorPtr result) const {
   delegate_->OnSendToCompleted(result.Pass(), forward_callback_);
 }
 
+UDPSocketWrapper::ReceiverBindingCallback::ReceiverBindingCallback(
+    UDPSocketWrapper* delegate,
+    const Callback<void(NetworkErrorPtr, NetAddressPtr)>& wrapper_callback)
+    : delegate_(delegate), wrapper_callback_(wrapper_callback) {
+}
+
+UDPSocketWrapper::ReceiverBindingCallback::~ReceiverBindingCallback() {
+}
+
+void UDPSocketWrapper::ReceiverBindingCallback::Run(
+    NetworkErrorPtr result,
+    NetAddressPtr addr,
+    InterfaceRequest<UDPSocketReceiver> request) const {
+  delegate_->StartReceivingData(request.Pass());
+  wrapper_callback_.Run(result.Pass(), addr.Pass());
+}
+
 UDPSocketWrapper::ReceivedData::ReceivedData() {}
 UDPSocketWrapper::ReceivedData::~ReceivedData() {}
 
 UDPSocketWrapper::SendRequest::SendRequest() {}
 UDPSocketWrapper::SendRequest::~SendRequest() {}
 
 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket)
-  : socket_(socket.Pass()),
-    max_receive_queue_size_(kDefaultReceiveQueueSlots),
-    max_pending_sends_(1),
-    current_pending_sends_(0) {
+    : binding_(this),
+      socket_(socket.Pass()),
+      max_receive_queue_size_(kDefaultReceiveQueueSlots),
+      max_pending_sends_(1),
+      current_pending_sends_(0) {
   Initialize(0);
 }
 
 UDPSocketWrapper::UDPSocketWrapper(UDPSocketPtr socket,
                                    uint32_t receive_queue_slots,
                                    uint32_t requested_max_pending_sends)
-  : socket_(socket.Pass()),
-    max_receive_queue_size_(receive_queue_slots),
-    max_pending_sends_(1),
-    current_pending_sends_(0) {
+    : binding_(this),
+      socket_(socket.Pass()),
+      max_receive_queue_size_(receive_queue_slots),
+      max_pending_sends_(1),
+      current_pending_sends_(0) {
   Initialize(requested_max_pending_sends);
 }
 
 UDPSocketWrapper::~UDPSocketWrapper() {
   while (!receive_queue_.empty()) {
     delete receive_queue_.front();
     receive_queue_.pop();
   }
   while (!send_requests_.empty()) {
     delete send_requests_.front();
     send_requests_.pop();
   }
 }
 
 void UDPSocketWrapper::AllowAddressReuse(const ErrorCallback& callback) {
   socket_->AllowAddressReuse(callback);
 }
 
 void UDPSocketWrapper::Bind(
     NetAddressPtr addr,
     const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
-  socket_->Bind(addr.Pass(), callback);
+  socket_->Bind(
+      addr.Pass(),
+      BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>(
+          new ReceiverBindingCallback(this, callback))));
 }
 
 void UDPSocketWrapper::Connect(
     NetAddressPtr remote_addr,
     const Callback<void(NetworkErrorPtr, NetAddressPtr)>& callback) {
-  socket_->Connect(remote_addr.Pass(), callback);
+  socket_->Connect(
+      remote_addr.Pass(),
+      BindOrConnectCallback(static_cast<BindOrConnectCallback::Runnable*>(
+          new ReceiverBindingCallback(this, callback))));
 }
 
 void UDPSocketWrapper::SetSendBufferSize(uint32_t size,
                                          const ErrorCallback& callback) {
   socket_->SetSendBufferSize(size, callback);
 }
 
 void UDPSocketWrapper::SetReceiveBufferSize(uint32_t size,
                                             const ErrorCallback& callback) {
   socket_->SetReceiveBufferSize(size, callback);
@@ skipping 50 matching lines @@
 
   MOJO_DCHECK(receive_queue_.size() < max_receive_queue_size_);
   ReceivedData* received_data = new ReceivedData();
   received_data->result = result.Pass();
   received_data->src_addr = src_addr.Pass();
   received_data->data = data.Pass();
   receive_queue_.push(received_data);
 }
 
 void UDPSocketWrapper::Initialize(uint32_t requested_max_pending_sends) {
-  socket_.set_client(this);
   socket_->NegotiateMaxPendingSendRequests(
       requested_max_pending_sends,
       Callback<void(uint32_t)>(
           static_cast< Callback<void(uint32_t)>::Runnable*>(
               new NegotiateCallbackHandler(this))));
-  socket_->ReceiveMore(max_receive_queue_size_);
 }
 
 void UDPSocketWrapper::OnNegotiateMaxPendingSendRequestsCompleted(
     uint32_t actual_size) {
   MOJO_DCHECK(max_pending_sends_ == 1);
 
   if (actual_size == 0) {
     assert(false);
     return;
   }
@@ skipping 24 matching lines @@
   socket_->SendTo(
       request->dest_addr.Pass(), request->data.Pass(),
       ErrorCallback(static_cast<ErrorCallback::Runnable*>(
           new SendCallbackHandler(this, request->callback))));
 
   delete request;
 
   return true;
 }
 
+void UDPSocketWrapper::StartReceivingData(
+    InterfaceRequest<UDPSocketReceiver> request) {
+  binding_.Bind(request.Pass());
+  socket_->ReceiveMore(max_receive_queue_size_);
+}
+
 }  // namespace mojo