De-Clientize UDPSocket service

mojo/services/network/udp_socket_apptest.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 "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_test_base.h"
@@ skipping 210 matching lines @@
   NetAddressPtr src_addr_;
   Array<uint8_t> data_;
 };
 
 struct ReceiveResult {
   NetworkErrorPtr result;
   NetAddressPtr addr;
   Array<uint8_t> data;
 };
 
-class UDPSocketClientImpl : public UDPSocketClient {
+class UDPSocketReceiverImpl : public UDPSocketReceiver {
  public:
-  UDPSocketClientImpl() : run_loop_(nullptr), expected_receive_count_(0) {}
+  UDPSocketReceiverImpl() : run_loop_(nullptr), expected_receive_count_(0) {}
 
-  ~UDPSocketClientImpl() override {
+  ~UDPSocketReceiverImpl() override {
     while (!results_.empty()) {
       delete results_.front();
       results_.pop();
     }
   }
 
   std::queue<ReceiveResult*>* results() {
     return &results_;
   }
 
@@ skipping 22 matching lines @@
     if (results_.size() == expected_receive_count_ && run_loop_) {
       expected_receive_count_ = 0;
       run_loop_->Quit();
     }
   }
 
   base::RunLoop* run_loop_;
   std::queue<ReceiveResult*> results_;
   size_t expected_receive_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(UDPSocketClientImpl);
+  DISALLOW_COPY_AND_ASSIGN(UDPSocketReceiverImpl);
 };
 
 class UDPSocketAppTest : public test::ApplicationTestBase {
  public:
-  UDPSocketAppTest() {}
+  UDPSocketAppTest() : receiver_binding_(&receiver_) {}
   ~UDPSocketAppTest() override {}
 
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
     ApplicationConnection* connection =
         application_impl()->ConnectToApplication("mojo:network_service");
     connection->ConnectToService(&network_service_);
 
     network_service_->CreateUDPSocket(GetProxy(&socket_));
-    socket_.set_client(&receiver_);
+
+    UDPSocketReceiverPtr receiver_proxy;
+    receiver_binding_.Bind(&receiver_proxy);
+    socket_->SetReceiver(receiver_proxy.Pass());
   }
 
  protected:
   NetworkServicePtr network_service_;
   UDPSocketPtr socket_;
-  UDPSocketClientImpl receiver_;
+  UDPSocketReceiverImpl receiver_;
+  Binding<UDPSocketReceiver> receiver_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(UDPSocketAppTest);
 };
 
 }  // namespace
 
 TEST_F(UDPSocketAppTest, Settings) {
   TestCallback callback1;
   socket_->AllowAddressReuse(callback1.callback());
   callback1.WaitForResult();
@@ skipping 94 matching lines @@
   TestCallbackWithAddress callback1;
   socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
-  UDPSocketClientImpl client_socket_receiver;
-  client_socket.set_client(&client_socket_receiver);
+
+  UDPSocketReceiverImpl client_socket_receiver;
+  UDPSocketReceiverPtr receiver_proxy;
+  Binding<UDPSocketReceiver> receiver_binding(&client_socket_receiver,
+                                              &receiver_proxy);
+  client_socket->SetReceiver(receiver_proxy.Pass());
 
   TestCallbackWithAddress callback2;
   client_socket->Connect(server_addr.Clone(), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 6;
@@ skipping 174 matching lines @@
                 receive_callbacks[j].result()->code);
       EXPECT_FALSE(receive_callbacks[j].src_addr());
       EXPECT_TRUE(receive_callbacks[j].data().Equals(
           CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize)));
     }
   }
 }
 
 }  // namespace service
 }  // namespace mojo