HostResolver is exposed to Native Client.

BUG=114225
TEST=PPAPINaClTest.HostResolverPrivate_*

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=127443

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=127668

Review URL: https://chromiumcodereview.appspot.com/9704080

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@128199 0039d316-1c4b-4281-b951-d872f2087c98

chrome/test/ui/ppapi_uitest.cc

@@ -474,15 +474,37 @@ TEST_PPAPI_NACL_VIA_HTTP_DISALLOWED_SOCKETS(UDPSocketPrivateDisallowed)
 
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(TCPServerSocketPrivate)
 TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(TCPServerSocketPrivate)
-TEST_PPAPI_NACL_VIA_HTTP(TCPServerSocketPrivate)
+// TODO(ygorshenin): http://crbug.com/116480.
+TEST_PPAPI_NACL_VIA_HTTP(DISABLED_TCPServerSocketPrivate)
 
-TEST_PPAPI_IN_PROCESS_VIA_HTTP(HostResolverPrivate_Empty)
+TEST_PPAPI_IN_PROCESS_VIA_HTTP(HostResolverPrivate_Create)
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(HostResolverPrivate_Resolve)
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(HostResolverPrivate_ResolveIPV4)
-TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(HostResolverPrivate_Empty)
+TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(HostResolverPrivate_Create)
 TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(HostResolverPrivate_Resolve)
 TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(HostResolverPrivate_ResolveIPV4)
 
+// Undeterministically can't be found on Windows. http://crbug.com/119260
+#if defined(OS_WIN)
+#define MAYBE_HostResolverPrivate_Create \
+  DISABLED_HostResolverPrivate_Create
+#define MAYBE_HostResolverPrivate_Resolve \
+  DISABLED_HostResolverPrivate_Resolve
+#define MAYBE_HostResolverPrivate_ResolveIPV4 \
+  DISABLED_HostResolverPrivate_ResolveIPV4
+#else
+#define MAYBE_HostResolverPrivate_Create \
+  HostResolverPrivate_Create
+#define MAYBE_HostResolverPrivate_Resolve \
+  HostResolverPrivate_Resolve
+#define MAYBE_HostResolverPrivate_ResolveIPV4 \
+  HostResolverPrivate_ResolveIPV4
+#endif
+
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_HostResolverPrivate_Create)
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_HostResolverPrivate_Resolve)
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_HostResolverPrivate_ResolveIPV4)
+
 // URLLoader tests.
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(URLLoader_BasicGET)
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(URLLoader_BasicPOST)
@@ -767,13 +789,30 @@ TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetFamily)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetPort)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetAddress)
 
+// Frequently timing out on Windows. http://crbug.com/115440
+#if defined(OS_WIN)
+#define MAYBE_NetAddressPrivateUntrusted_Describe \
+  DISABLED_NetAddressPrivateUntrusted_Describe
+#define MAYBE_NetAddressPrivateUntrusted_ReplacePort \
+  DISABLED_NetAddressPrivateUntrusted_ReplacePort
+#define MAYBE_NetAddressPrivateUntrusted_GetPort \
+  DISABLED_NetAddressPrivateUntrusted_GetPort
+#else
+#define MAYBE_NetAddressPrivateUntrusted_Describe \
+  NetAddressPrivateUntrusted_Describe
+#define MAYBE_NetAddressPrivateUntrusted_ReplacePort \
+  NetAddressPrivateUntrusted_ReplacePort
+#define MAYBE_NetAddressPrivateUntrusted_GetPort \
+  NetAddressPrivateUntrusted_GetPort
+#endif
+
 TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_AreEqual)
 TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_AreHostsEqual)
-TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_Describe)
-TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_ReplacePort)
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_NetAddressPrivateUntrusted_Describe)
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_NetAddressPrivateUntrusted_ReplacePort)
 TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetAnyAddress)
 TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetFamily)
-TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetPort)
+TEST_PPAPI_NACL_VIA_HTTP(MAYBE_NetAddressPrivateUntrusted_GetPort)
 TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetAddress)
 
 TEST_PPAPI_IN_PROCESS(NetworkMonitorPrivate_Basic)

ppapi/native_client/src/shared/ppapi_proxy/browser_globals.cc

@@ -238,6 +238,13 @@ const PPB_Graphics3DTrusted* PPBGraphics3DTrustedInterface() {
   return ppb;
 }
 
+const PPB_HostResolver_Private* PPBHostResolverPrivateInterface() {
+  static const PPB_HostResolver_Private* ppb =
+      static_cast<const PPB_HostResolver_Private*>(
+          GetBrowserInterfaceSafe(PPB_HOSTRESOLVER_PRIVATE_INTERFACE));
+  return ppb;
+}
+
 const PPB_ImageData* PPBImageDataInterface() {
   static const PPB_ImageData* ppb = static_cast<const PPB_ImageData*>(
       GetBrowserInterfaceSafe(PPB_IMAGEDATA_INTERFACE));

ppapi/native_client/src/shared/ppapi_proxy/browser_globals.h

@@ -36,6 +36,7 @@
 #include "ppapi/c/ppb_var_array_buffer.h"
 #include "ppapi/c/ppb_view.h"
 #include "ppapi/c/ppb_websocket.h"
+#include "ppapi/c/private/ppb_host_resolver_private.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/c/private/ppb_tcp_server_socket_private.h"
@@ -112,6 +113,7 @@ const PPB_Gamepad* PPBGamepadInterface();
 const PPB_Graphics2D* PPBGraphics2DInterface();
 const PPB_Graphics3D* PPBGraphics3DInterface();
 const PPB_Graphics3DTrusted* PPBGraphics3DTrustedInterface();
+const PPB_HostResolver_Private* PPBHostResolverPrivateInterface();
 const PPB_ImageData* PPBImageDataInterface();
 const PPB_ImageDataTrusted* PPBImageDataTrustedInterface();
 const PPB_InputEvent* PPBInputEventInterface();

ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_host_resolver_private_rpc_server.cc

+// Copyright (c) 2012 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.
+//
+// SRPC-abstraction wrappers around PPB_HostResolver_Private functions.
+
+#include <limits>
+#include <sys/types.h>
+
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/shared/ppapi_proxy/browser_callback.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/object_serialize.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/var.h"
+#include "srpcgen/ppb_rpc.h"
+
+using ppapi_proxy::DebugPrintf;
+using ppapi_proxy::DeleteRemoteCallbackInfo;
+using ppapi_proxy::MakeRemoteCompletionCallback;
+using ppapi_proxy::PPBHostResolverPrivateInterface;
+using ppapi_proxy::SerializeTo;
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_Create(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Instance instance,
+    // output
+    PP_Resource* resource) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  *resource = PPBHostResolverPrivateInterface()->Create(instance);
+
+  DebugPrintf("PPB_HostResolver_Private::Create: " \
+              "resource=%"NACL_PRId32"\n", *resource);
+}
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_IsHostResolver(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource resource,
+    // output
+    int32_t* is_host_resolver) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  PP_Bool pp_success =
+      PPBHostResolverPrivateInterface()->IsHostResolver(resource);
+  *is_host_resolver = PP_ToBool(pp_success);
+
+  DebugPrintf("PPB_HostResolver_Private::IsHostResolver: " \
+              "is_host_resolver=%d\n", *is_host_resolver);
+}
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_Resolve(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource host_resolver,
+    const char* host,
+    int32_t port,
+    nacl_abi_size_t hint_bytes, char* hint,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (hint_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_HostResolver_Private_Hint))) {
+    return;
+  }
+
+  if (port < std::numeric_limits<uint16_t>::min() ||
+      port > std::numeric_limits<uint16_t>::max()) {
+    return;
+  }
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBHostResolverPrivateInterface()->Resolve(
+      host_resolver,
+      host,
+      static_cast<uint16_t>(port),
+      reinterpret_cast<const PP_HostResolver_Private_Hint*>(hint),
+      remote_callback);
+
+  DebugPrintf("PPB_HostResolver_Private::Resolve: " \
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetCanonicalName(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource host_resolver,
+    // outputs
+    nacl_abi_size_t* canonical_name_bytes, char* canonical_name) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  pp::Var pp_canonical_name(
+      pp::PASS_REF,
+      PPBHostResolverPrivateInterface()->GetCanonicalName(host_resolver));
+
+  if (!SerializeTo(&pp_canonical_name.pp_var(),
+                   canonical_name,
+                   canonical_name_bytes)) {
+    return;
+  }
+
+  DebugPrintf("PPB_HostResolver_Private::GetCanonicalName: " \
+              "canonical_name=%s\n", pp_canonical_name.AsString().c_str());
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetSize(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource host_resolver,
+    // output
+    int32_t* size) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  uint32_t list_size =
+      PPBHostResolverPrivateInterface()->GetSize(
+          host_resolver);
+
+  DebugPrintf("PPB_HostResolver_Private::GetSize: " \
+              "size=%"NACL_PRIu32"\n", list_size);
+
+  if (list_size > static_cast<uint32_t>(std::numeric_limits<int32_t>::max()))
+    return;
+  *size = static_cast<int32_t>(list_size);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetNetAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource host_resolver,
+    int32_t index,
+    // outputs
+    nacl_abi_size_t* addr_bytes, char* addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  PP_Bool pp_success =
+      PPBHostResolverPrivateInterface()->GetNetAddress(
+          host_resolver,
+          index,
+          reinterpret_cast<PP_NetAddress_Private*>(addr));
+  *success = PP_FromBool(pp_success);
+
+  DebugPrintf("PPB_HostResolver_Private::GetNetAddress: " \
+              "success=%d\n", *success);
+}

ppapi/native_client/src/shared/ppapi_proxy/build.scons

@@ -49,6 +49,7 @@ env.DualLibrary('ppapi_browser',
                  'browser_ppb_gamepad_rpc_server.cc',
                  'browser_ppb_graphics_2d_rpc_server.cc',
                  'browser_ppb_graphics_3d_rpc_server.cc',
+                 'browser_ppb_host_resolver_private_rpc_server.cc',
                  'browser_ppb_image_data_rpc_server.cc',
                  'browser_ppb_input_event_rpc_server.cc',
                  'browser_ppb_instance_rpc_server.cc',

ppapi/native_client/src/shared/ppapi_proxy/nacl.scons

@@ -68,6 +68,7 @@ libppruntime = env.NaClSdkLibrary(
     'plugin_ppb_gamepad.cc',
     'plugin_ppb_graphics_2d.cc',
     'plugin_ppb_graphics_3d.cc',
+    'plugin_ppb_host_resolver_private.cc',
     'plugin_ppb_image_data.cc',
     'plugin_ppb_input_event.cc',
     'plugin_ppb_instance.cc',

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc

@@ -21,6 +21,7 @@
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_gamepad.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_graphics_2d.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_graphics_3d.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_ppb_host_resolver_private.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_image_data.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_input_event.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_instance.h"
@@ -73,6 +74,8 @@ InterfaceMapElement interface_map[] = {
   { PPB_GAMEPAD_INTERFACE, PluginGamepad::GetInterface(), true },
   { PPB_GRAPHICS_2D_INTERFACE, PluginGraphics2D::GetInterface(), true },
   { PPB_GRAPHICS_3D_INTERFACE, PluginGraphics3D::GetInterface(), true },
+  { PPB_HOSTRESOLVER_PRIVATE_INTERFACE,
+    PluginHostResolverPrivate::GetInterface(), true },
   { PPB_IMAGEDATA_INTERFACE, PluginImageData::GetInterface(), true },
   { PPB_INPUT_EVENT_INTERFACE, PluginInputEvent::GetInterface(), true },
   { PPB_INSTANCE_INTERFACE, PluginInstance::GetInterface(), true },

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_host_resolver_private.cc

+// Copyright (c) 2012 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 "native_client/src/shared/ppapi_proxy/plugin_ppb_host_resolver_private.h"
+
+#include "native_client/src/include/nacl_scoped_ptr.h"
+#include "native_client/src/include/portability.h"
+#include "native_client/src/shared/ppapi_proxy/object_serialize.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_callback.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "native_client/src/shared/srpc/nacl_srpc.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_host_resolver_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+namespace ppapi_proxy {
+
+namespace {
+
+PP_Resource Create(PP_Instance instance) {
+  DebugPrintf("PPB_HostResolver_Private::Create: " \
+              "instance=%"NACL_PRId32"\n", instance);
+
+  PP_Resource resource;
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_Create(
+          GetMainSrpcChannel(),
+          instance,
+          &resource);
+
+  DebugPrintf("PPB_HostResolver_Private::Create: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    return kInvalidResourceId;
+  return resource;
+}
+
+PP_Bool IsHostResolver(PP_Resource resource) {
+  DebugPrintf("PPB_HostResolver_Private::IsHostResolver: " \
+              "resource=%"NACL_PRId32"\n", resource);
+
+  int32_t is_host_resolver;
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::
+      PPB_HostResolver_Private_IsHostResolver(
+          GetMainSrpcChannel(),
+          resource,
+          &is_host_resolver);
+
+  DebugPrintf("PPB_HostResolver_Private::IsHostResolver: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && is_host_resolver)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+int32_t Resolve(PP_Resource host_resolver,
+                const char* host,
+                uint16_t port,
+                const PP_HostResolver_Private_Hint* hint,
+                PP_CompletionCallback callback) {
+  DebugPrintf("PPB_HostResolver_Private::Resolve: " \
+              "resource=%"NACL_PRId32"\n", host_resolver);
+
+  int32_t callback_id = CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0)
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::
+      PPB_HostResolver_Private_Resolve(
+          GetMainSrpcChannel(),
+          host_resolver,
+          host,
+          port,
+          static_cast<nacl_abi_size_t>(sizeof(*hint)),
+          reinterpret_cast<char*>(
+              const_cast<PP_HostResolver_Private_Hint*>(hint)),
+          callback_id,
+          &pp_error);
+
+  DebugPrintf("PPB_HostResolver_Private::Resolve: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error);
+}
+
+PP_Var GetCanonicalName(PP_Resource host_resolver) {
+  DebugPrintf("PPB_HostResolver_Private::GetCanonicalName: " \
+              "resource=%"NACL_PRId32"\n", host_resolver);
+
+  nacl_abi_size_t canonical_name_size = kMaxReturnVarSize;
+  nacl::scoped_array<char> canonical_name_bytes(new char[canonical_name_size]);
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::
+      PPB_HostResolver_Private_GetCanonicalName(
+          GetMainSrpcChannel(),
+          host_resolver,
+          &canonical_name_size, canonical_name_bytes.get());
+
+  DebugPrintf("PPB_HostResolver_Private::GetCanonicalName: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  PP_Var canonical_name = PP_MakeUndefined();
+  if (srpc_result == NACL_SRPC_RESULT_OK) {
+    (void) DeserializeTo(canonical_name_bytes.get(),
+                         canonical_name_size,
+                         1,
+                         &canonical_name);
+  }
+  return canonical_name;
+}
+
+uint32_t GetSize(PP_Resource host_resolver) {
+  DebugPrintf("PPB_HostResolver_Private::GetSize: " \
+              "resource=%"NACL_PRId32"\n", host_resolver);
+
+  int32_t size;
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::
+      PPB_HostResolver_Private_GetSize(
+          GetMainSrpcChannel(),
+          host_resolver,
+          &size);
+
+  DebugPrintf("PPB_HostResolver_Private::GetSize: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK)
+    return static_cast<uint32_t>(size);
+  return 0;
+}
+
+PP_Bool GetNetAddress(PP_Resource host_resolver,
+                      uint32_t index,
+                      PP_NetAddress_Private* addr) {
+  DebugPrintf("PPB_HostResolver_Private::GetNetAddress: " \
+              "resource=%"NACL_PRId32"\n", host_resolver);
+
+  nacl_abi_size_t addr_size = sizeof(*addr);
+  int32_t success;
+  NaClSrpcError srpc_result =
+      PpbHostResolverPrivateRpcClient::
+      PPB_HostResolver_Private_GetNetAddress(
+          GetMainSrpcChannel(),
+          host_resolver,
+          static_cast<int32_t>(index),
+          &addr_size, reinterpret_cast<char*>(addr),
+          &success);
+
+  DebugPrintf("PPB_HostResolver_Private::GetNetAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && success != 0)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+}  // namespace
+
+const PPB_HostResolver_Private*
+  PluginHostResolverPrivate::GetInterface() {
+  static const PPB_HostResolver_Private hostresolver_private_interface = {
+    Create,
+    IsHostResolver,
+    Resolve,
+    GetCanonicalName,
+    GetSize,
+    GetNetAddress
+  };
+  return &hostresolver_private_interface;
+}
+
+}  // namespace ppapi_proxy

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_host_resolver_private.h

+// Copyright (c) 2012 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.
+
+#ifndef NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_HOST_RESOLVER_PRIVATE_H_
+#define NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_HOST_RESOLVER_PRIVATE_H_
+
+#include "native_client/src/include/nacl_macros.h"
+#include "ppapi/c/private/ppb_host_resolver_private.h"
+
+namespace ppapi_proxy {
+
+// Implements the untrusted side of the PPB_HostResolver_Private interface.
+class PluginHostResolverPrivate {
+ public:
+  static const PPB_HostResolver_Private* GetInterface();
+
+ private:
+  NACL_DISALLOW_COPY_AND_ASSIGN(PluginHostResolverPrivate);
+};
+
+}  // namespace ppapi_proxy
+
+#endif  // NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_HOST_RESOLVER_PRIVATE_H_

ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy.gyp

@@ -31,8 +31,8 @@
         'browser_callback.cc',
         'browser_globals.cc',
         'browser_nacl_file_rpc_server.cc',
-        'browser_ppb_audio_rpc_server.cc',
         'browser_ppb_audio_config_rpc_server.cc',
+        'browser_ppb_audio_rpc_server.cc',
         'browser_ppb_core_rpc_server.cc',
         'browser_ppb_cursor_control_rpc_server.cc',
         'browser_ppb_file_io_rpc_server.cc',
@@ -44,6 +44,7 @@
         'browser_ppb_gamepad_rpc_server.cc',
         'browser_ppb_graphics_2d_rpc_server.cc',
         'browser_ppb_graphics_3d_rpc_server.cc',
+        'browser_ppb_host_resolver_private_rpc_server.cc',
         'browser_ppb_image_data_rpc_server.cc',
         'browser_ppb_input_event_rpc_server.cc',
         'browser_ppb_instance_rpc_server.cc',

ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy_untrusted.gyp

@@ -65,6 +65,7 @@
           'plugin_ppb_gamepad.cc',
           'plugin_ppb_graphics_2d.cc',
           'plugin_ppb_graphics_3d.cc',
+          'plugin_ppb_host_resolver_private.cc',
           'plugin_ppb_image_data.cc',
           'plugin_ppb_input_event.cc',
           'plugin_ppb_instance.cc',

ppapi/native_client/src/shared/ppapi_proxy/ppb_host_resolver_private.srpc

+# Copyright (c) 2012 The Native Client Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# RPC methods used to implement PPB_HostResolver_Private calls from
+# the plugin.  See ppapi/c/private/ppb_host_resolver_private.h for
+# interface details.
+
+{
+  'name': 'PpbHostResolverPrivateRpc',
+  'rpcs': [
+    {'name': 'PPB_HostResolver_Private_Create',
+     'inputs': [['instance', 'PP_Instance'],
+               ],
+     'outputs': [['resource', 'PP_Resource'],
+                ]
+    },
+    {'name': 'PPB_HostResolver_Private_IsHostResolver',
+     'inputs': [['resource', 'PP_Resource'],
+                ],
+     'outputs': [['is_host_resolver', 'int32_t'],     # PP_Bool
+                 ]
+    },
+    {'name': 'PPB_HostResolver_Private_Resolve',
+     'inputs': [['host_resolver', 'PP_Resource'],
+                ['host', 'string'],                   # const char*
+                ['port', 'int32_t'],                  # uint16_t
+                ['hint', 'char[]'],        # const PP_HostResolver_Private_Hint*
+                ['callback_id', 'int32_t']            # PP_CompletionCallback
+               ],
+     'outputs': [['pp_error', 'int32_t'],
+                ]
+    },
+    {'name': 'PPB_HostResolver_Private_GetCanonicalName',
+     'inputs': [['host_resolver', 'PP_Resource'],
+               ],
+     'outputs': [['canonical_name', 'char[]']         # PP_Var
+                ]
+    },
+    {'name': 'PPB_HostResolver_Private_GetSize',
+     'inputs': [['host_resolver', 'PP_Resource'],
+               ],
+     'outputs': [['size', 'int32_t'],                 # uint32_t
+                ]
+    },
+    {'name': 'PPB_HostResolver_Private_GetNetAddress',
+     'inputs': [['host_resolver', 'PP_Resource'],
+                ['index', 'int32_t'],                 # uint32_t
+               ],
+     'outputs': [['addr', 'char[]'],                  # PP_NetAddress_Private*
+                 ['success', 'int32_t'],              # PP_Bool
+                ]
+    }
+  ]
+}
\ No newline at end of file

ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc

@@ -1654,6 +1654,120 @@ NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_GetTransferBuffer(
   return retval;
 }
 
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_Create(
+    NaClSrpcChannel* channel,
+    PP_Instance instance,
+    PP_Resource* resource)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_Create:i:i",
+      instance,
+      resource
+  );
+  return retval;
+}
+
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_IsHostResolver(
+    NaClSrpcChannel* channel,
+    PP_Resource resource,
+    int32_t* is_host_resolver)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_IsHostResolver:i:i",
+      resource,
+      is_host_resolver
+  );
+  return retval;
+}
+
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_Resolve(
+    NaClSrpcChannel* channel,
+    PP_Resource host_resolver,
+    const char* host,
+    int32_t port,
+    nacl_abi_size_t hint_bytes, char* hint,
+    int32_t callback_id,
+    int32_t* pp_error)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_Resolve:isiCi:i",
+      host_resolver,
+      host,
+      port,
+      hint_bytes, hint,
+      callback_id,
+      pp_error
+  );
+  return retval;
+}
+
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_GetCanonicalName(
+    NaClSrpcChannel* channel,
+    PP_Resource host_resolver,
+    nacl_abi_size_t* canonical_name_bytes, char* canonical_name)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_GetCanonicalName:i:C",
+      host_resolver,
+      canonical_name_bytes, canonical_name
+  );
+  return retval;
+}
+
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_GetSize(
+    NaClSrpcChannel* channel,
+    PP_Resource host_resolver,
+    int32_t* size)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_GetSize:i:i",
+      host_resolver,
+      size
+  );
+  return retval;
+}
+
+NaClSrpcError PpbHostResolverPrivateRpcClient::PPB_HostResolver_Private_GetNetAddress(
+    NaClSrpcChannel* channel,
+    PP_Resource host_resolver,
+    int32_t index,
+    nacl_abi_size_t* addr_bytes, char* addr,
+    int32_t* success)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_HostResolver_Private_GetNetAddress:ii:Ci",
+      host_resolver,
+      index,
+      addr_bytes, addr,
+      success
+  );
+  return retval;
+}
+
 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_GetNativeImageDataFormat(
     NaClSrpcChannel* channel,
     int32_t* format)  {

ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc

@@ -1330,6 +1330,96 @@ static void PPB_Graphics3DTrusted_GetTransferBufferDispatcher(
   );
 }
 
+static void PPB_HostResolver_Private_CreateDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_Create(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_HostResolver_Private_IsHostResolverDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_IsHostResolver(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_HostResolver_Private_ResolveDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_Resolve(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->arrays.str,
+      inputs[2]->u.ival,
+      inputs[3]->u.count, inputs[3]->arrays.carr,
+      inputs[4]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_HostResolver_Private_GetCanonicalNameDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetCanonicalName(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr
+  );
+}
+
+static void PPB_HostResolver_Private_GetSizeDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetSize(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_HostResolver_Private_GetNetAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbHostResolverPrivateRpcServer::PPB_HostResolver_Private_GetNetAddress(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
 static void PPB_ImageData_GetNativeImageDataFormatDispatcher(
     NaClSrpcRpc* rpc,
     NaClSrpcArg** inputs,
@@ -3118,6 +3208,12 @@ NaClSrpcHandlerDesc PpbRpcs::srpc_methods[] = {
   { "PPB_Graphics3DTrusted_CreateTransferBuffer:iii:i", PPB_Graphics3DTrusted_CreateTransferBufferDispatcher },
   { "PPB_Graphics3DTrusted_DestroyTransferBuffer:ii:", PPB_Graphics3DTrusted_DestroyTransferBufferDispatcher },
   { "PPB_Graphics3DTrusted_GetTransferBuffer:ii:hi", PPB_Graphics3DTrusted_GetTransferBufferDispatcher },
+  { "PPB_HostResolver_Private_Create:i:i", PPB_HostResolver_Private_CreateDispatcher },
+  { "PPB_HostResolver_Private_IsHostResolver:i:i", PPB_HostResolver_Private_IsHostResolverDispatcher },
+  { "PPB_HostResolver_Private_Resolve:isiCi:i", PPB_HostResolver_Private_ResolveDispatcher },
+  { "PPB_HostResolver_Private_GetCanonicalName:i:C", PPB_HostResolver_Private_GetCanonicalNameDispatcher },
+  { "PPB_HostResolver_Private_GetSize:i:i", PPB_HostResolver_Private_GetSizeDispatcher },
+  { "PPB_HostResolver_Private_GetNetAddress:ii:Ci", PPB_HostResolver_Private_GetNetAddressDispatcher },
   { "PPB_ImageData_GetNativeImageDataFormat::i", PPB_ImageData_GetNativeImageDataFormatDispatcher },
   { "PPB_ImageData_IsImageDataFormatSupported:i:i", PPB_ImageData_IsImageDataFormatSupportedDispatcher },
   { "PPB_ImageData_Create:iiCi:i", PPB_ImageData_CreateDispatcher },

ppapi/native_client/src/shared/ppapi_proxy/run_srpcgen.py

@@ -71,6 +71,7 @@ all_units = [
          'ppb_gamepad.srpc',
          'ppb_graphics_2d.srpc',
          'ppb_graphics_3d.srpc',
+         'ppb_host_resolver_private.srpc',
          'ppb_image_data.srpc',
          'ppb_input_event.srpc',
          'ppb_instance.srpc',

ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h

@@ -671,6 +671,51 @@ class PpbGraphics3DRpcServer {
   void operator=(const PpbGraphics3DRpcServer);
 };  // class PpbGraphics3DRpcServer
 
+class PpbHostResolverPrivateRpcServer {
+ public:
+  static void PPB_HostResolver_Private_Create(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Instance instance,
+      PP_Resource* resource);
+  static void PPB_HostResolver_Private_IsHostResolver(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource resource,
+      int32_t* is_host_resolver);
+  static void PPB_HostResolver_Private_Resolve(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource host_resolver,
+      const char* host,
+      int32_t port,
+      nacl_abi_size_t hint_bytes, char* hint,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static void PPB_HostResolver_Private_GetCanonicalName(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource host_resolver,
+      nacl_abi_size_t* canonical_name_bytes, char* canonical_name);
+  static void PPB_HostResolver_Private_GetSize(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource host_resolver,
+      int32_t* size);
+  static void PPB_HostResolver_Private_GetNetAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource host_resolver,
+      int32_t index,
+      nacl_abi_size_t* addr_bytes, char* addr,
+      int32_t* success);
+
+ private:
+  PpbHostResolverPrivateRpcServer();
+  PpbHostResolverPrivateRpcServer(const PpbHostResolverPrivateRpcServer&);
+  void operator=(const PpbHostResolverPrivateRpcServer);
+};  // class PpbHostResolverPrivateRpcServer
+
 class PpbImageDataRpcServer {
  public:
   static void PPB_ImageData_GetNativeImageDataFormat(

ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h

@@ -585,6 +585,45 @@ class PpbGraphics3DRpcClient {
   void operator=(const PpbGraphics3DRpcClient);
 };  // class PpbGraphics3DRpcClient
 
+class PpbHostResolverPrivateRpcClient {
+ public:
+  static NaClSrpcError PPB_HostResolver_Private_Create(
+      NaClSrpcChannel* channel,
+      PP_Instance instance,
+      PP_Resource* resource);
+  static NaClSrpcError PPB_HostResolver_Private_IsHostResolver(
+      NaClSrpcChannel* channel,
+      PP_Resource resource,
+      int32_t* is_host_resolver);
+  static NaClSrpcError PPB_HostResolver_Private_Resolve(
+      NaClSrpcChannel* channel,
+      PP_Resource host_resolver,
+      const char* host,
+      int32_t port,
+      nacl_abi_size_t hint_bytes, char* hint,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static NaClSrpcError PPB_HostResolver_Private_GetCanonicalName(
+      NaClSrpcChannel* channel,
+      PP_Resource host_resolver,
+      nacl_abi_size_t* canonical_name_bytes, char* canonical_name);
+  static NaClSrpcError PPB_HostResolver_Private_GetSize(
+      NaClSrpcChannel* channel,
+      PP_Resource host_resolver,
+      int32_t* size);
+  static NaClSrpcError PPB_HostResolver_Private_GetNetAddress(
+      NaClSrpcChannel* channel,
+      PP_Resource host_resolver,
+      int32_t index,
+      nacl_abi_size_t* addr_bytes, char* addr,
+      int32_t* success);
+
+ private:
+  PpbHostResolverPrivateRpcClient();
+  PpbHostResolverPrivateRpcClient(const PpbHostResolverPrivateRpcClient&);
+  void operator=(const PpbHostResolverPrivateRpcClient);
+};  // class PpbHostResolverPrivateRpcClient
+
 class PpbImageDataRpcClient {
  public:
   static NaClSrpcError PPB_ImageData_GetNativeImageDataFormat(

ppapi/ppapi_sources.gypi

@@ -98,6 +98,7 @@
       'c/private/ppb_flash_tcp_socket.h',
       'c/private/ppb_flash_udp_socket.h',
       'c/private/ppb_gpu_blacklist_private.h',
+      'c/private/ppb_host_resolver_private.h',
       'c/private/ppb_instance_private.h',
       'c/private/ppb_nacl_private.h',
       'c/private/ppb_net_address_private.h',
@@ -106,6 +107,7 @@
       'c/private/ppp_instance_private.h',
       'c/private/ppb_network_list_private.h',
       'c/private/ppb_network_monitor_private.h',
+      'c/private/ppb_tcp_server_socket_private.h',
       'c/private/ppb_tcp_socket_private.h',
       'c/private/ppb_udp_socket_private.h',
 
@@ -311,6 +313,8 @@
       'tests/test_case.h',
       'tests/test_empty.cc',
       'tests/test_empty.h',
+      'tests/test_host_resolver_private.cc',
+      'tests/test_host_resolver_private.h',
       'tests/test_net_address_private_untrusted.cc',
       'tests/test_net_address_private_untrusted.h',
       'tests/test_tcp_server_socket_private.cc',
@@ -403,8 +407,6 @@
       'tests/test_graphics_2d.h',
       'tests/test_graphics_3d.cc',
       'tests/test_graphics_3d.h',
-      'tests/test_host_resolver_private.cc',
-      'tests/test_host_resolver_private.h',
       'tests/test_image_data.cc',
       'tests/test_image_data.h',
       'tests/test_input_event.cc',