Add GetBoundAddress to PPB_UDPSocket_Private

ppapi/tests/test_udp_socket_private_shared.cc

 // Copyright (c) 2011 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 <string.h>
 
 #include "ppapi/cpp/module.h"
 #include "ppapi/tests/test_udp_socket_private_shared.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
@@ skipping 57 matching lines @@
     return ReportError("PPB_TCPSocket_Private::Connect", rv);
 
   rv = tcp_socket_private_interface_->GetLocalAddress(*socket, address);
   if (rv != PP_TRUE)
     return ReportError("PPB_TCPSocket_Private::GetLocalAddress", rv);
 
   PASS();
 }
 
 std::string TestUDPSocketPrivateShared::CreateAndBindUDPSocket(
-    const PP_NetAddress_Private *address,
+    PP_NetAddress_Private *address,
     PP_Resource *socket) {
   *socket = udp_socket_private_interface_->Create(instance_->pp_instance());
   if (0 == *socket)
     return "PPB_UDPSocket_Private::Create failed";
   if (!udp_socket_private_interface_->IsUDPSocket(*socket))
     return "PPB_UDPSocket_Private::IsUDPSocket failed";
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = udp_socket_private_interface_->Bind(
       *socket, address,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
 
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("PPB_UDPSocket_Private::Bind", rv);
 
+  if (!udp_socket_private_interface_->GetBoundAddress(*socket, address))

[viettrungluu, 2012/02/07 23:03:58]

Please add tests that GetBoundAddress correctly *fails* in the case that it
hasn't been bound, etc.

[mtilburg1, 2012/02/08 15:27:01]

Done.

+      return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
+
   PASS();
 }
 
 std::string TestUDPSocketPrivateShared::TestCreate() {
   PP_Resource udp_socket;
   std::string error_message;
 
   udp_socket = udp_socket_private_interface_->Create(0);
   if (0 != udp_socket)
     return "PPB_UDPSocket_Private::Create returns valid socket " \
@@ skipping 10 matching lines @@
 
 std::string TestUDPSocketPrivateShared::TestConnect() {
   PP_NetAddress_Private server_address, client_address;
   PP_Resource tcp_socket_server, tcp_socket_client;
   std::string error_message;
 
   error_message = GenerateNetAddress(&tcp_socket_server, &server_address);
   if (!error_message.empty())
     return error_message;
   error_message = GenerateNetAddress(&tcp_socket_client, &client_address);
-  if (error_message.empty())
+  if (!error_message.empty())
     return error_message;
 
   PP_Resource socket_server, socket_client;
   error_message = CreateAndBindUDPSocket(&server_address, &socket_server);
-  if (error_message.empty())
+  if (!error_message.empty())
     return error_message;
   error_message = CreateAndBindUDPSocket(&client_address, &socket_client);
-  if (error_message.empty())
+  if (!error_message.empty())
     return error_message;
 
   static const char* const kMessage =
       "Simple message that will be sent via UDP";
   static const size_t kMessageBufferSize = 1024;
   char message_buffer[kMessageBufferSize];
 
   TestCompletionCallback write_cb(instance_->pp_instance(), force_async_);
   int32_t write_rv = udp_socket_private_interface_->SendTo(
       socket_client,
@@ skipping 26 matching lines @@
   ASSERT_EQ(0, strncmp(kMessage, message_buffer, strlen(kMessage)));
 
   udp_socket_private_interface_->Close(socket_server);
   udp_socket_private_interface_->Close(socket_client);
 
   tcp_socket_private_interface_->Disconnect(tcp_socket_server);
   tcp_socket_private_interface_->Disconnect(tcp_socket_client);
 
   PASS();
 }