GetDocumentURL is added to PPB_Testing_Dev.

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"
 
 REGISTER_TEST_CASE(UDPSocketPrivateShared);
 
-// TODO(ygorshenin): get rid of using external server in tests,
-// http://crbug.com/105863
-const char* const TestUDPSocketPrivateShared::kHost = "www.google.com";
-
 TestUDPSocketPrivateShared::TestUDPSocketPrivateShared(
     TestingInstance* instance)
     : TestCase(instance),
       tcp_socket_private_interface_(NULL),
       udp_socket_private_interface_(NULL) {
 }
 
 bool TestUDPSocketPrivateShared::Init() {
   tcp_socket_private_interface_ =
       reinterpret_cast<PPB_TCPSocket_Private const*>(
           pp::Module::Get()->GetBrowserInterface(
               PPB_TCPSOCKET_PRIVATE_INTERFACE));
   if (!tcp_socket_private_interface_)
     instance_->AppendError("TCPSocketPrivate interface not available");
 
   udp_socket_private_interface_ =
       reinterpret_cast<PPB_UDPSocket_Private const*>(
           pp::Module::Get()->GetBrowserInterface(
               PPB_UDPSOCKET_PRIVATE_INTERFACE));
   if (!udp_socket_private_interface_)
     instance_->AppendError("UDPSocketPrivate interface not available");
 
-  return tcp_socket_private_interface_ && udp_socket_private_interface_ &&
+  bool init_host_port = false;
+  if (!GetLocalHostPort(instance_->pp_instance(), &host_, &port_))
+    instance_->AppendError("Can't init host and port");
+  else
+    init_host_port = true;
+
+  return tcp_socket_private_interface_ &&
+      udp_socket_private_interface_ &&
+      init_host_port &&
       InitTestingInterface();
 }
 
 void TestUDPSocketPrivateShared::RunTests(const std::string& filter) {
   RUN_TEST(Create, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
 }
 
 void TestUDPSocketPrivateShared::QuitMessageLoop() {
   testing_interface_->QuitMessageLoop(instance_->pp_instance());
 }
 
 std::string TestUDPSocketPrivateShared::GenerateNetAddress(
     PP_Resource* socket, PP_NetAddress_Private* address) {
    *socket = tcp_socket_private_interface_->Create(instance_->pp_instance());
    if (0 == *socket)
      return "PPB_TCPSocket_Private::Create failed";
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = tcp_socket_private_interface_->Connect(
-      *socket, kHost, kPort,
+      *socket, host_.c_str(), port_,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("PPB_TCPSocket_Private::Connect", rv);
 
   rv = tcp_socket_private_interface_->GetLocalAddress(*socket, address);
   if (rv != PP_TRUE)
@@ skipping 101 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();
 }