PPB_NetAddress_Private: add getter methods for sockaddr.

This CL is mostly contributed by Vinay(vinaya@adobe.com): http://codereview.chromium.org/9235035

Comparing with 9235035, this change:
- fixes the NaCl Proxy.
- adds untrusted tests.
- does other small fixes.

BUG=None
TEST=test_net_address_private and test_net_address_private_untrusted

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

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

21 files changed, 619 insertions, 34 deletions

diff --git a/AUTHORS b/AUTHORS
index 2f774e0..5c441f7 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -131,6 +131,7 @@ Mike Tilburg <mtilburg@adobe.com>
 Peter Brophy <pbrophy@adobe.com>
 Robert Goldberg <goldberg@adobe.com>
 Don Woodward <woodward@adobe.com>
+Vinay Anantharaman <vinaya@adobe.com>
 Naveen Bobbili <naveenbobbili@motorola.com>
 Vamshikrishna Yellenki <vamshi@motorola.com>
 Robert Nagy <robert.nagy@gmail.com>
diff --git a/chrome/test/ui/ppapi_uitest.cc b/chrome/test/ui/ppapi_uitest.cc
index 42236f5..2adb376 100644
--- a/chrome/test/ui/ppapi_uitest.cc
+++ b/chrome/test/ui/ppapi_uitest.cc
@@ -688,18 +688,27 @@ TEST_PPAPI_IN_PROCESS(NetAddressPrivate_Describe)
 TEST_PPAPI_IN_PROCESS(NetAddressPrivate_ReplacePort)
 TEST_PPAPI_IN_PROCESS(NetAddressPrivate_GetAnyAddress)
 TEST_PPAPI_IN_PROCESS(NetAddressPrivate_DescribeIPv6)
+TEST_PPAPI_IN_PROCESS(NetAddressPrivate_GetFamily)
+TEST_PPAPI_IN_PROCESS(NetAddressPrivate_GetPort)
+TEST_PPAPI_IN_PROCESS(NetAddressPrivate_GetAddress)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_AreEqual)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_AreHostsEqual)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_Describe)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_ReplacePort)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetAnyAddress)
 TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_DescribeIPv6)
+TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetFamily)
+TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetPort)
+TEST_PPAPI_OUT_OF_PROCESS(NetAddressPrivate_GetAddress)
 
 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(NetAddressPrivateUntrusted_GetAnyAddress)
+TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetFamily)
+TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetPort)
+TEST_PPAPI_NACL_VIA_HTTP(NetAddressPrivateUntrusted_GetAddress)
 
 // PPB_TCPSocket_Private currently isn't supported in-process.
 TEST_F(OutOfProcessPPAPITest, TCPSocketPrivate) {
diff --git a/ppapi/api/private/ppb_net_address_private.idl b/ppapi/api/private/ppb_net_address_private.idl
index 97bc59f..ecf6416 100644
--- a/ppapi/api/private/ppb_net_address_private.idl
+++ b/ppapi/api/private/ppb_net_address_private.idl
@@ -8,7 +8,8 @@
  */
 
 label Chrome {
-  M17 = 0.1
+    M17 = 0.1,
+    M18 = 1.0
 };
 
 /**
@@ -58,4 +59,28 @@ interface PPB_NetAddress_Private {
     */
   void GetAnyAddress([in] PP_Bool is_ipv6,
                      [out] PP_NetAddress_Private addr);
+
+  /**
+    * Gets the address family.
+    */
+  [version=1.0]
+  uint16_t GetFamily([in] PP_NetAddress_Private addr);
+  
+  /**
+    * Gets the port. The port is returned in host byte order.
+    */
+  [version=1.0]
+  uint16_t GetPort([in] PP_NetAddress_Private addr);
+
+  /**
+    * Gets the address. The output, address, must be large enough for the
+    * current socket family. The output will be the binary representation of an
+    * address for the current socket family. For IPv4 and IPv6 the address is in
+    * network byte order. PP_TRUE is returned if the address was successfully
+    * retrieved.
+    */
+  [version=1.0]
+  PP_Bool GetAddress([in] PP_NetAddress_Private addr,
+                     [out] mem_t address,
+                     [in] uint16_t address_size);
 };
diff --git a/ppapi/c/private/ppb_net_address_private.h b/ppapi/c/private/ppb_net_address_private.h
index 949cc1c..a414fbe 100644
--- a/ppapi/c/private/ppb_net_address_private.h
+++ b/ppapi/c/private/ppb_net_address_private.h
@@ -4,7 +4,7 @@
  */
 
 /* From private/ppb_net_address_private.idl,
- *   modified Wed Jan  4 11:09:00 2012.
+ *   modified Sun Feb  5 10:36:30 2012.
  */
 
 #ifndef PPAPI_C_PRIVATE_PPB_NET_ADDRESS_PRIVATE_H_
@@ -17,7 +17,8 @@
 #include "ppapi/c/pp_var.h"
 
 #define PPB_NETADDRESS_PRIVATE_INTERFACE_0_1 "PPB_NetAddress_Private;0.1"
-#define PPB_NETADDRESS_PRIVATE_INTERFACE PPB_NETADDRESS_PRIVATE_INTERFACE_0_1
+#define PPB_NETADDRESS_PRIVATE_INTERFACE_1_0 "PPB_NetAddress_Private;1.0"
+#define PPB_NETADDRESS_PRIVATE_INTERFACE PPB_NETADDRESS_PRIVATE_INTERFACE_1_0
 
 /**
  * @file
@@ -49,7 +50,7 @@ PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_NetAddress_Private, 132);
  * The <code>PPB_NetAddress_Private</code> interface provides operations on
  * network addresses.
  */
-struct PPB_NetAddress_Private_0_1 {
+struct PPB_NetAddress_Private_1_0 {
   /**
    * Returns PP_TRUE if the two addresses are equal (host and port).
    */
@@ -78,9 +79,41 @@ struct PPB_NetAddress_Private_0_1 {
    * Gets the "any" address (for IPv4 or IPv6); for use with UDP Bind.
    */
   void (*GetAnyAddress)(PP_Bool is_ipv6, struct PP_NetAddress_Private* addr);
+  /**
+   * Gets the address family.
+   */
+  uint16_t (*GetFamily)(const struct PP_NetAddress_Private* addr);
+  /**
+   * Gets the port. The port is returned in host byte order.
+   */
+  uint16_t (*GetPort)(const struct PP_NetAddress_Private* addr);
+  /**
+   * Gets the address. The output, address, must be large enough for the
+   * current socket family. The output will be the binary representation of an
+   * address for the current socket family. For IPv4 and IPv6 the address is in
+   * network byte order. PP_TRUE is returned if the address was successfully
+   * retrieved.
+   */
+  PP_Bool (*GetAddress)(const struct PP_NetAddress_Private* addr,
+                        void* address,
+                        uint16_t address_size);
 };
 
-typedef struct PPB_NetAddress_Private_0_1 PPB_NetAddress_Private;
+typedef struct PPB_NetAddress_Private_1_0 PPB_NetAddress_Private;
+
+struct PPB_NetAddress_Private_0_1 {
+  PP_Bool (*AreEqual)(const struct PP_NetAddress_Private* addr1,
+                      const struct PP_NetAddress_Private* addr2);
+  PP_Bool (*AreHostsEqual)(const struct PP_NetAddress_Private* addr1,
+                           const struct PP_NetAddress_Private* addr2);
+  struct PP_Var (*Describe)(PP_Module module,
+                            const struct PP_NetAddress_Private* addr,
+                            PP_Bool include_port);
+  PP_Bool (*ReplacePort)(const struct PP_NetAddress_Private* src_addr,
+                         uint16_t port,
+                         struct PP_NetAddress_Private* dest_addr);
+  void (*GetAnyAddress)(PP_Bool is_ipv6, struct PP_NetAddress_Private* addr);
+};
 /**
  * @}
  */
diff --git a/ppapi/cpp/private/net_address_private.cc b/ppapi/cpp/private/net_address_private.cc
index 3b91795..1973012 100644
--- a/ppapi/cpp/private/net_address_private.cc
+++ b/ppapi/cpp/private/net_address_private.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -76,8 +76,35 @@ void NetAddressPrivate::GetAnyAddress(bool is_ipv6,
                                       PP_NetAddress_Private* addr) {
   if (!has_interface<PPB_NetAddress_Private>())
     return;
-  get_interface<PPB_NetAddress_Private>()->GetAnyAddress(PP_FromBool(is_ipv6),
-                                                         addr);
+  get_interface<PPB_NetAddress_Private>()->GetAnyAddress(
+      PP_FromBool(is_ipv6),
+      addr);
+}
+
+// static
+uint16_t NetAddressPrivate::GetFamily(const PP_NetAddress_Private& addr) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return 0;
+  return get_interface<PPB_NetAddress_Private>()->GetFamily(&addr);
+}
+
+// static
+uint16_t NetAddressPrivate::GetPort(const PP_NetAddress_Private& addr) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return 0;
+  return get_interface<PPB_NetAddress_Private>()->GetPort(&addr);
+}
+
+// static
+bool NetAddressPrivate::GetAddress(const PP_NetAddress_Private& addr,
+                                   void* address,
+                                   uint16_t address_size) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return false;
+  return PP_ToBool(get_interface<PPB_NetAddress_Private>()->GetAddress(
+      &addr,
+      address,
+      address_size));
 }
 
 }  // namespace pp
diff --git a/ppapi/cpp/private/net_address_private.h b/ppapi/cpp/private/net_address_private.h
index a2f8d880..fe4c9a7 100644
--- a/ppapi/cpp/private/net_address_private.h
+++ b/ppapi/cpp/private/net_address_private.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -28,6 +28,10 @@ class NetAddressPrivate {
                           uint16_t port,
                           PP_NetAddress_Private* addr_out);
   static void GetAnyAddress(bool is_ipv6, PP_NetAddress_Private* addr);
+  static uint16_t GetFamily(const PP_NetAddress_Private& addr);
+  static uint16_t GetPort(const PP_NetAddress_Private& addr);
+  static bool GetAddress(const PP_NetAddress_Private& addr,
+                         void* address, uint16_t address_size);
 };
 
 }  // namespace pp
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_net_address_private_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_net_address_private_rpc_server.cc
index 55de726..6d355a9 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_net_address_private_rpc_server.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_net_address_private_rpc_server.cc
@@ -177,3 +177,77 @@ void PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetAnyAddress(
 
   rpc->result = NACL_SRPC_RESULT_OK;
 }
+
+void PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetFamily(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    nacl_abi_size_t addr_bytes, char* addr,
+    // output
+    int32_t* addr_family) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private))) {
+    return;
+  }
+
+  *addr_family = PPBNetAddressPrivateInterface()->GetFamily(
+      reinterpret_cast<PP_NetAddress_Private*>(addr));
+
+  DebugPrintf("PPB_NetAddress_Private::GetFamily\n");
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetPort(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    nacl_abi_size_t addr_bytes, char* addr,
+    // output
+    int32_t* port) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private))) {
+    return;
+  }
+
+  *port = PPBNetAddressPrivateInterface()->GetPort(
+      reinterpret_cast<PP_NetAddress_Private*>(addr));
+
+  DebugPrintf("PPB_NetAddress_Private::GetPort\n");
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    nacl_abi_size_t addr_bytes, char* addr,
+    // output
+    nacl_abi_size_t* address_bytes, char* address,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private))) {
+    return;
+  }
+
+  PP_Bool pp_success = PPBNetAddressPrivateInterface()->GetAddress(
+      reinterpret_cast<PP_NetAddress_Private*>(addr),
+      address, static_cast<uint16_t>(*address_bytes));
+
+  DebugPrintf("PPB_NetAddress_Private::GetAddress: pp_success=%d\n",
+              pp_success);
+
+  *success = (pp_success == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
index 8d1734d..b33400c 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
@@ -82,8 +82,10 @@ InterfaceMapElement interface_map[] = {
   { PPB_MOUSE_INPUT_EVENT_INTERFACE_1_1,
     PluginInputEvent::GetMouseInterface1_1(), true },
   { PPB_MOUSELOCK_INTERFACE, PluginMouseLock::GetInterface(), true },
-  { PPB_NETADDRESS_PRIVATE_INTERFACE, PluginNetAddressPrivate::GetInterface(),
-    true },
+  { PPB_NETADDRESS_PRIVATE_INTERFACE_0_1,
+    PluginNetAddressPrivate::GetInterface0_1(), true },
+  { PPB_NETADDRESS_PRIVATE_INTERFACE_1_0,
+    PluginNetAddressPrivate::GetInterface1_0(), true },
   { PPB_OPENGLES2_INTERFACE, PluginGraphics3D::GetOpenGLESInterface(),
     true },
   { PPB_PDF_INTERFACE, PluginPDF::GetInterface(), true },
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.cc b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.cc
index 521217c..bf4989b 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.cc
@@ -159,15 +159,97 @@ void GetAnyAddress(PP_Bool is_ipv6, PP_NetAddress_Private* addr) {
               NaClSrpcErrorString(srpc_result));
 }
 
+uint16_t GetFamily(const PP_NetAddress_Private* addr) {
+  DebugPrintf("PPB_NetAddress_Private::GetFamily\n");
+
+  nacl_abi_size_t addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<PP_NetAddress_Private*>(addr));
+  int32_t addr_family;
+
+  NaClSrpcError srpc_result =
+      PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetFamily(
+          GetMainSrpcChannel(),
+          addr_bytes, raw_addr,
+          &addr_family);
+
+  DebugPrintf("PPB_NetAddress_Private::GetFamily: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  return static_cast<uint16_t>(static_cast<uint32_t>(addr_family));
+}
+
+uint16_t GetPort(const PP_NetAddress_Private* addr) {
+  DebugPrintf("PPB_NetAddress_Private::GetPort\n");
+
+  nacl_abi_size_t addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<PP_NetAddress_Private*>(addr));
+  int32_t port;
+
+  NaClSrpcError srpc_result =
+      PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetPort(
+          GetMainSrpcChannel(),
+          addr_bytes, raw_addr,
+          &port);
+
+  DebugPrintf("PPB_NetAddress_Private::GetPort: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  return static_cast<uint16_t>(static_cast<uint32_t>(port));
+}
+
+PP_Bool GetAddress(const PP_NetAddress_Private* addr,
+                   void* address,
+                   uint16_t address_size) {
+  DebugPrintf("PP_NetAddress_Private::GetAddress");
+
+  int32_t success = 0;
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<PP_NetAddress_Private*>(addr));
+  nacl_abi_size_t address_bytes_size = address_size;
+  NaClSrpcError srpc_result =
+      PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetAddress(
+          GetMainSrpcChannel(),
+          static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)), raw_addr,
+          &address_bytes_size, static_cast<char*>(address),
+          &success);
+
+  DebugPrintf("PPB_NetAddressPrivate::GetAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && success)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
 }  // namespace
 
-const PPB_NetAddress_Private* PluginNetAddressPrivate::GetInterface() {
-  static const PPB_NetAddress_Private netaddress_private_interface = {
+// static
+const PPB_NetAddress_Private_0_1* PluginNetAddressPrivate::GetInterface0_1() {
+  static const PPB_NetAddress_Private_0_1 netaddress_private_interface = {
+    AreEqual,
+    AreHostsEqual,
+    Describe,
+    ReplacePort,
+    GetAnyAddress
+  };
+  return &netaddress_private_interface;
+}
+
+// static
+const PPB_NetAddress_Private_1_0* PluginNetAddressPrivate::GetInterface1_0() {
+  static const PPB_NetAddress_Private_1_0 netaddress_private_interface = {
     AreEqual,
     AreHostsEqual,
     Describe,
     ReplacePort,
     GetAnyAddress,
+    GetFamily,
+    GetPort,
+    GetAddress
   };
   return &netaddress_private_interface;
 }
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.h b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.h
index 8c81c8c..e08d3b2 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_net_address_private.h
@@ -13,7 +13,8 @@ namespace ppapi_proxy {
 // Implements the untrusted side of the PPB_NetAddress_Private interface.
 class PluginNetAddressPrivate {
  public:
-  static const PPB_NetAddress_Private* GetInterface();
+  static const PPB_NetAddress_Private_0_1* GetInterface0_1();
+  static const PPB_NetAddress_Private_1_0* GetInterface1_0();
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PluginNetAddressPrivate);
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_net_address_private.srpc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_net_address_private.srpc
index de66184..6a9f5b9 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppb_net_address_private.srpc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_net_address_private.srpc
@@ -44,5 +44,24 @@
      'outputs': [['addr', 'char[]'],                 # PP_NetAddress_Private*
                 ]
     },
+    {'name': 'PPB_NetAddress_Private_GetFamily',
+     'inputs': [['addr', 'char[]'],                  # PP_NetAddress_Private*
+               ],
+     'outputs': [['addr_family', 'int32_t'],         # uint16_t
+                ]
+    },
+    {'name': 'PPB_NetAddress_Private_GetPort',
+     'inputs': [['addr', 'char[]'],                  # PP_NetAddress_Private*
+               ],
+     'outputs': [['port', 'int32_t'],                # uint16_t
+                ]
+    },
+    {'name': 'PPB_NetAddress_Private_GetAddress',
+     'inputs': [['addr', 'char[]'],                  # PP_NetAddress_Private*
+               ],
+     'outputs': [['address', 'char[]'],
+                 ['success', 'int32_t'],             # PP_Bool
+                ]
+    },
    ]
 }
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
index a0d7d44..68c19ab 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
@@ -2026,6 +2026,59 @@ NaClSrpcError PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetAnyAddres
   return retval;
 }
 
+NaClSrpcError PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetFamily(
+    NaClSrpcChannel* channel,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t* addr_family)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_NetAddress_Private_GetFamily:C:i",
+      addr_bytes, addr,
+      addr_family
+  );
+  return retval;
+}
+
+NaClSrpcError PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetPort(
+    NaClSrpcChannel* channel,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t* port)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_NetAddress_Private_GetPort:C:i",
+      addr_bytes, addr,
+      port
+  );
+  return retval;
+}
+
+NaClSrpcError PpbNetAddressPrivateRpcClient::PPB_NetAddress_Private_GetAddress(
+    NaClSrpcChannel* channel,
+    nacl_abi_size_t addr_bytes, char* addr,
+    nacl_abi_size_t* address_bytes, char* address,
+    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_NetAddress_Private_GetAddress:C:Ci",
+      addr_bytes, addr,
+      address_bytes, address,
+      success
+  );
+  return retval;
+}
+
 NaClSrpcError PpbPdfRpcClient::PPB_PDF_GetLocalizedString(
     NaClSrpcChannel* channel,
     PP_Instance instance,
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
index 9476805..91fdd0d 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
@@ -1619,6 +1619,49 @@ static void PPB_NetAddress_Private_GetAnyAddressDispatcher(
   );
 }
 
+static void PPB_NetAddress_Private_GetFamilyDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetFamily(
+      rpc,
+      done,
+      inputs[0]->u.count, inputs[0]->arrays.carr,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_NetAddress_Private_GetPortDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetPort(
+      rpc,
+      done,
+      inputs[0]->u.count, inputs[0]->arrays.carr,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_NetAddress_Private_GetAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbNetAddressPrivateRpcServer::PPB_NetAddress_Private_GetAddress(
+      rpc,
+      done,
+      inputs[0]->u.count, inputs[0]->arrays.carr,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
 static void PPB_PDF_GetLocalizedStringDispatcher(
     NaClSrpcRpc* rpc,
     NaClSrpcArg** inputs,
@@ -2973,6 +3016,9 @@ NaClSrpcHandlerDesc PpbRpcs::srpc_methods[] = {
   { "PPB_NetAddress_Private_Describe:iCi:C", PPB_NetAddress_Private_DescribeDispatcher },
   { "PPB_NetAddress_Private_ReplacePort:Ci:Ci", PPB_NetAddress_Private_ReplacePortDispatcher },
   { "PPB_NetAddress_Private_GetAnyAddress:i:C", PPB_NetAddress_Private_GetAnyAddressDispatcher },
+  { "PPB_NetAddress_Private_GetFamily:C:i", PPB_NetAddress_Private_GetFamilyDispatcher },
+  { "PPB_NetAddress_Private_GetPort:C:i", PPB_NetAddress_Private_GetPortDispatcher },
+  { "PPB_NetAddress_Private_GetAddress:C:Ci", PPB_NetAddress_Private_GetAddressDispatcher },
   { "PPB_PDF_GetLocalizedString:ii:C", PPB_PDF_GetLocalizedStringDispatcher },
   { "PPB_PDF_GetResourceImage:ii:i", PPB_PDF_GetResourceImageDispatcher },
   { "PPB_PDF_GetFontFileWithFallback:iCCi:i", PPB_PDF_GetFontFileWithFallbackDispatcher },
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h b/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
index b2fda1b25..c0e96ee 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
@@ -841,6 +841,22 @@ class PpbNetAddressPrivateRpcServer {
       NaClSrpcClosure* done,
       int32_t is_ipv6,
       nacl_abi_size_t* addr_bytes, char* addr);
+  static void PPB_NetAddress_Private_GetFamily(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t* addr_family);
+  static void PPB_NetAddress_Private_GetPort(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t* port);
+  static void PPB_NetAddress_Private_GetAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      nacl_abi_size_t addr_bytes, char* addr,
+      nacl_abi_size_t* address_bytes, char* address,
+      int32_t* success);
 
  private:
   PpbNetAddressPrivateRpcServer();
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h b/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
index 6585b48..1f3b993 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
@@ -737,6 +737,19 @@ class PpbNetAddressPrivateRpcClient {
       NaClSrpcChannel* channel,
       int32_t is_ipv6,
       nacl_abi_size_t* addr_bytes, char* addr);
+  static NaClSrpcError PPB_NetAddress_Private_GetFamily(
+      NaClSrpcChannel* channel,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t* addr_family);
+  static NaClSrpcError PPB_NetAddress_Private_GetPort(
+      NaClSrpcChannel* channel,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t* port);
+  static NaClSrpcError PPB_NetAddress_Private_GetAddress(
+      NaClSrpcChannel* channel,
+      nacl_abi_size_t addr_bytes, char* addr,
+      nacl_abi_size_t* address_bytes, char* address,
+      int32_t* success);
 
  private:
   PpbNetAddressPrivateRpcClient();
diff --git a/ppapi/shared_impl/private/net_address_private_impl.cc b/ppapi/shared_impl/private/net_address_private_impl.cc
index bf548d1..5edf5a4 100644
--- a/ppapi/shared_impl/private/net_address_private_impl.cc
+++ b/ppapi/shared_impl/private/net_address_private_impl.cc
@@ -28,9 +28,6 @@
 #endif
 
 #if defined(OS_WIN)
-// The type of |sockaddr::sa_family|.
-typedef ADDRESS_FAMILY sa_family_t;
-
 #define s6_addr16 u.Word
 #endif
 
@@ -51,8 +48,40 @@ COMPILE_ASSERT(sizeof(reinterpret_cast<PP_NetAddress_Private*>(0)->data) >=
                sizeof(sockaddr_storage), PP_NetAddress_Private_data_too_small);
 #endif
 
-inline sa_family_t GetFamily(const PP_NetAddress_Private& addr) {
-  return reinterpret_cast<const sockaddr*>(addr.data)->sa_family;
+uint16_t GetFamily(const PP_NetAddress_Private* addr) {
+  return reinterpret_cast<const sockaddr*>(addr->data)->sa_family;
+}
+
+uint16_t GetPort(const PP_NetAddress_Private* addr) {
+  if (GetFamily(addr) == AF_INET)  {
+    const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
+    return ntohs(a->sin_port);
+  } else if (GetFamily(addr) == AF_INET6)  {
+    const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
+    return ntohs(a->sin6_port);
+  }
+
+  return 0;
+}
+
+PP_Bool GetAddress(const PP_NetAddress_Private* addr,
+                   void* address,
+                   uint16_t address_size) {
+  if (GetFamily(addr) == AF_INET)  {
+    const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
+    if (address_size >= sizeof(a->sin_addr.s_addr))  {
+      memcpy(address, &(a->sin_addr.s_addr), sizeof(a->sin_addr.s_addr));
+      return PP_TRUE;
+    }
+  } else if (GetFamily(addr) == AF_INET6)  {
+    const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
+    if (address_size >= sizeof(a->sin6_addr.s6_addr)) {
+      memcpy(address, &(a->sin6_addr.s6_addr), sizeof(a->sin6_addr.s6_addr));
+      return PP_TRUE;
+    }
+  }
+
+  return PP_FALSE;
 }
 
 PP_Bool AreHostsEqual(const PP_NetAddress_Private* addr1,
@@ -61,16 +90,16 @@ PP_Bool AreHostsEqual(const PP_NetAddress_Private* addr1,
       !NetAddressPrivateImpl::ValidateNetAddress(*addr2))
     return PP_FALSE;
 
-  if (GetFamily(*addr1) != GetFamily(*addr2))
+  if (GetFamily(addr1) != GetFamily(addr2))
     return PP_FALSE;
 
-  if (GetFamily(*addr1) == AF_INET) {
+  if (GetFamily(addr1) == AF_INET) {
     const sockaddr_in* a1 = reinterpret_cast<const sockaddr_in*>(addr1->data);
     const sockaddr_in* a2 = reinterpret_cast<const sockaddr_in*>(addr2->data);
     return PP_FromBool(a1->sin_addr.s_addr == a2->sin_addr.s_addr);
   }
 
-  if (GetFamily(*addr1) == AF_INET6) {
+  if (GetFamily(addr1) == AF_INET6) {
     const sockaddr_in6* a1 = reinterpret_cast<const sockaddr_in6*>(addr1->data);
     const sockaddr_in6* a2 = reinterpret_cast<const sockaddr_in6*>(addr2->data);
     return PP_FromBool(a1->sin6_flowinfo == a2->sin6_flowinfo &&
@@ -90,13 +119,13 @@ PP_Bool AreEqual(const PP_NetAddress_Private* addr1,
     return PP_FALSE;
 
   // Note: Here, we know that |addr1| and |addr2| have the same family.
-  if (GetFamily(*addr1) == AF_INET) {
+  if (GetFamily(addr1) == AF_INET) {
     const sockaddr_in* a1 = reinterpret_cast<const sockaddr_in*>(addr1->data);
     const sockaddr_in* a2 = reinterpret_cast<const sockaddr_in*>(addr2->data);
     return PP_FromBool(a1->sin_port == a2->sin_port);
   }
 
-  if (GetFamily(*addr1) == AF_INET6) {
+  if (GetFamily(addr1) == AF_INET6) {
     const sockaddr_in6* a1 = reinterpret_cast<const sockaddr_in6*>(addr1->data);
     const sockaddr_in6* a2 = reinterpret_cast<const sockaddr_in6*>(addr2->data);
     return PP_FromBool(a1->sin6_port == a2->sin6_port);
@@ -207,7 +236,7 @@ PP_Var Describe(PP_Module /*module*/,
   // |getnameinfo()| collapses length-one runs of zeros (and also doesn't
   // display the scope).
   // TODO(viettrungluu): Consider switching to this on Linux.
-  switch (GetFamily(*addr)) {
+  switch (GetFamily(addr)) {
     case AF_INET: {
       const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
       return StringVar::StringToPPVar(
@@ -239,13 +268,13 @@ PP_Bool ReplacePort(const struct PP_NetAddress_Private* src_addr,
   if (!NetAddressPrivateImpl::ValidateNetAddress(*src_addr))
     return PP_FALSE;
 
-  if (GetFamily(*src_addr) == AF_INET) {
+  if (GetFamily(src_addr) == AF_INET) {
     memmove(dest_addr, src_addr, sizeof(*src_addr));
     reinterpret_cast<sockaddr_in*>(dest_addr->data)->sin_port = htons(port);
     return PP_TRUE;
   }
 
-  if (GetFamily(*src_addr) == AF_INET6) {
+  if (GetFamily(src_addr) == AF_INET6) {
     memmove(dest_addr, src_addr, sizeof(*src_addr));
     reinterpret_cast<sockaddr_in6*>(dest_addr->data)->sin6_port = htons(port);
     return PP_TRUE;
@@ -269,7 +298,7 @@ void GetAnyAddress(PP_Bool is_ipv6, PP_NetAddress_Private* addr) {
   }
 }
 
-const PPB_NetAddress_Private net_address_private_interface = {
+const PPB_NetAddress_Private_0_1 net_address_private_interface_0_1 = {
   &AreEqual,
   &AreHostsEqual,
   &Describe,
@@ -277,13 +306,29 @@ const PPB_NetAddress_Private net_address_private_interface = {
   &GetAnyAddress
 };
 
+const PPB_NetAddress_Private_1_0 net_address_private_interface_1_0 = {
+  &AreEqual,
+  &AreHostsEqual,
+  &Describe,
+  &ReplacePort,
+  &GetAnyAddress,
+  &GetFamily,
+  &GetPort,
+  &GetAddress
+};
+
 }  // namespace
 
 namespace thunk {
 
 PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_0_1*
 GetPPB_NetAddress_Private_0_1_Thunk() {
-  return &net_address_private_interface;
+  return &net_address_private_interface_0_1;
+}
+
+PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_1_0*
+GetPPB_NetAddress_Private_1_0_Thunk() {
+  return &net_address_private_interface_1_0;
 }
 
 }  // namespace thunk
@@ -299,11 +344,11 @@ bool NetAddressPrivateImpl::ValidateNetAddress(
 
   // TODO(viettrungluu): more careful validation?
   // Just do a size check for AF_INET.
-  if (GetFamily(addr) == AF_INET && addr.size >= sizeof(sockaddr_in))
+  if (GetFamily(&addr) == AF_INET && addr.size >= sizeof(sockaddr_in))
     return true;
 
   // Ditto for AF_INET6.
-  if (GetFamily(addr) == AF_INET6 && addr.size >= sizeof(sockaddr_in6))
+  if (GetFamily(&addr) == AF_INET6 && addr.size >= sizeof(sockaddr_in6))
     return true;
 
   // Reject everything else.
diff --git a/ppapi/tests/test_net_address_private.cc b/ppapi/tests/test_net_address_private.cc
index 3860617..ecb9bc9 100644
--- a/ppapi/tests/test_net_address_private.cc
+++ b/ppapi/tests/test_net_address_private.cc
@@ -1,9 +1,11 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "ppapi/tests/test_net_address_private.h"
 
+#include <string.h>
+
 #include "ppapi/cpp/private/net_address_private.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/tests/test_utils.h"
@@ -80,6 +82,9 @@ void TestNetAddressPrivate::RunTests(const std::string& filter) {
   RUN_TEST(ReplacePort, filter);
   RUN_TEST(GetAnyAddress, filter);
   RUN_TEST(DescribeIPv6, filter);
+  RUN_TEST(GetFamily, filter);
+  RUN_TEST(GetPort, filter);
+  RUN_TEST(GetAddress, filter);
 }
 
 std::string TestNetAddressPrivate::TestAreEqual() {
@@ -244,3 +249,74 @@ std::string TestNetAddressPrivate::TestDescribeIPv6() {
 
   PASS();
 }
+
+std::string TestNetAddressPrivate::TestGetFamily() {
+  PP_NetAddress_Private ipv4 = MakeIPv4NetAddress("127.0.0.1", 80);
+  ASSERT_EQ(NetAddressPrivate::GetFamily(ipv4), AF_INET);
+
+  uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
+  PP_NetAddress_Private ipv6 = MakeIPv6NetAddress(ipv6_address,
+                                                  123,
+                                                  0);
+  ASSERT_EQ(NetAddressPrivate::GetFamily(ipv6), AF_INET6);
+
+  PASS();
+}
+
+std::string TestNetAddressPrivate::TestGetPort() {
+  PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress("127.0.0.1", 80);
+  ASSERT_EQ(NetAddressPrivate::GetPort(localhost_80), 80);
+
+  uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
+
+  PP_NetAddress_Private port_123 = MakeIPv6NetAddress(ipv6_address, 123, 0);
+  ASSERT_EQ(NetAddressPrivate::GetPort(port_123), 123);
+
+  PP_NetAddress_Private port_FFFF = MakeIPv6NetAddress(ipv6_address,
+                                                       0xFFFF,
+                                                       0);
+  ASSERT_EQ(NetAddressPrivate::GetPort(port_FFFF), 0xFFFF);
+
+  PASS();
+}
+
+std::string TestNetAddressPrivate::TestGetAddress() {
+  const int addr_storage_len = 16;
+  unsigned char addr_storage[addr_storage_len];
+
+  const char* ipv4_addr = "127.0.0.1";
+  uint32_t ipv4_addr_long = inet_addr(ipv4_addr);
+  PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(ipv4_addr, 80);
+  memset(addr_storage, 0, addr_storage_len);
+  ASSERT_TRUE(NetAddressPrivate::GetAddress(localhost_80,
+                                            addr_storage,
+                                            addr_storage_len));
+  ASSERT_EQ(memcmp(addr_storage, &ipv4_addr_long, 4), 0);
+
+  // Insufficient storage for address.
+  ASSERT_FALSE(NetAddressPrivate::GetAddress(localhost_80,
+                                             addr_storage,
+                                             1));
+
+  uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
+  PP_NetAddress_Private ipv6_addr = MakeIPv6NetAddress(ipv6_address,
+                                                       123,
+                                                       0);
+
+  // Ensure the ipv6 address is transformed properly into network order.
+  for (int i = 0; i < 8; i++)
+    ipv6_address[i] = htons(ipv6_address[i]);
+
+  memset(addr_storage, 0, addr_storage_len);
+  ASSERT_TRUE(NetAddressPrivate::GetAddress(ipv6_addr,
+                                            addr_storage,
+                                            addr_storage_len));
+  ASSERT_EQ(memcmp(addr_storage, ipv6_address, 16), 0);
+
+  // Insufficient storage for address.
+  ASSERT_FALSE(NetAddressPrivate::GetAddress(ipv6_addr,
+                                             addr_storage,
+                                             1));
+
+  PASS();
+}
diff --git a/ppapi/tests/test_net_address_private.h b/ppapi/tests/test_net_address_private.h
index 7dbd4bc..1aa9c04 100644
--- a/ppapi/tests/test_net_address_private.h
+++ b/ppapi/tests/test_net_address_private.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -23,8 +23,10 @@ class TestNetAddressPrivate : public TestCase {
   std::string TestDescribe();
   std::string TestReplacePort();
   std::string TestGetAnyAddress();
-
   std::string TestDescribeIPv6();
+  std::string TestGetFamily();
+  std::string TestGetPort();
+  std::string TestGetAddress();
 };
 
 #endif  // PAPPI_TESTS_TEST_NET_ADDRESS_PRIVATE_H_
diff --git a/ppapi/tests/test_net_address_private_untrusted.cc b/ppapi/tests/test_net_address_private_untrusted.cc
index 08c2410..d8e0996 100644
--- a/ppapi/tests/test_net_address_private_untrusted.cc
+++ b/ppapi/tests/test_net_address_private_untrusted.cc
@@ -47,6 +47,9 @@ void TestNetAddressPrivateUntrusted::RunTests(const std::string& filter) {
   RUN_TEST(Describe, filter);
   RUN_TEST(ReplacePort, filter);
   RUN_TEST(GetAnyAddress, filter);
+  RUN_TEST(GetFamily, filter);
+  RUN_TEST(GetPort, filter);
+  RUN_TEST(GetAddress, filter);
 }
 
 int32_t TestNetAddressPrivateUntrusted::Connect(TCPSocketPrivate* socket,
@@ -151,3 +154,52 @@ std::string TestNetAddressPrivateUntrusted::TestGetAnyAddress() {
 
   PASS();
 }
+
+std::string TestNetAddressPrivateUntrusted::TestGetFamily() {
+  pp::TCPSocketPrivate socket(instance_);
+  int32_t rv = Connect(&socket, host_, port_);
+  if (rv != PP_OK)
+    return ReportError("pp::TCPSocketPrivate::Connect", rv);
+
+  PP_NetAddress_Private remote_address;
+  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
+
+  ASSERT_EQ(NetAddressPrivate::GetFamily(remote_address),
+            NetAddressPrivate::GetFamily(remote_address));
+
+  socket.Disconnect();
+  PASS();
+}
+
+std::string TestNetAddressPrivateUntrusted::TestGetPort() {
+  pp::TCPSocketPrivate socket(instance_);
+  int32_t rv = Connect(&socket, host_, port_);
+  if (rv != PP_OK)
+    return ReportError("pp::TCPSocketPrivate::Connect", rv);
+
+  PP_NetAddress_Private remote_address;
+  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
+
+  ASSERT_EQ(NetAddressPrivate::GetPort(remote_address), port_);
+
+  socket.Disconnect();
+  PASS();
+}
+
+std::string TestNetAddressPrivateUntrusted::TestGetAddress() {
+  pp::TCPSocketPrivate socket(instance_);
+  int32_t rv = Connect(&socket, host_, port_);
+  if (rv != PP_OK)
+    return ReportError("pp::TCPSocketPrivate::Connect", rv);
+
+  PP_NetAddress_Private remote_address;
+  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
+
+  static const uint16_t buffer_size = sizeof(remote_address.data);
+  char buffer[buffer_size];
+  ASSERT_TRUE(NetAddressPrivate::GetAddress(remote_address, buffer,
+                                            buffer_size));
+
+  socket.Disconnect();
+  PASS();
+}
diff --git a/ppapi/tests/test_net_address_private_untrusted.h b/ppapi/tests/test_net_address_private_untrusted.h
index 25e764d..f1f0462 100644
--- a/ppapi/tests/test_net_address_private_untrusted.h
+++ b/ppapi/tests/test_net_address_private_untrusted.h
@@ -33,6 +33,9 @@ class TestNetAddressPrivateUntrusted : public TestCase {
   std::string TestDescribe();
   std::string TestReplacePort();
   std::string TestGetAnyAddress();
+  std::string TestGetFamily();
+  std::string TestGetPort();
+  std::string TestGetAddress();
 
   std::string host_;
   uint16_t port_;
diff --git a/ppapi/thunk/interfaces_ppb_private.h b/ppapi/thunk/interfaces_ppb_private.h
index 6513e0d..35a5704 100644
--- a/ppapi/thunk/interfaces_ppb_private.h
+++ b/ppapi/thunk/interfaces_ppb_private.h
@@ -22,6 +22,8 @@ PROXIED_IFACE(PPB_Instance, PPB_FLASHFULLSCREEN_INTERFACE_0_1,
               PPB_FlashFullscreen_0_1)
 PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE_0_1,
               PPB_NetAddress_Private_0_1)
+PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE_1_0,
+              PPB_NetAddress_Private_1_0)
 PROXIED_IFACE(PPB_TCPSocket_Private, PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3,
               PPB_TCPSocket_Private_0_3)
 PROXIED_IFACE(PPB_UDPSocket_Private, PPB_UDPSOCKET_PRIVATE_INTERFACE_0_2,