Exposed PPB_TCPServerSocketPrivate::GetLocalAddress().

BUG=223006
NOTRY=true
TEST=browser_tests:*TCPServerSocketPrivate*

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

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

15 files changed, 222 insertions, 71 deletions

diff --git a/ppapi/api/private/ppb_tcp_server_socket_private.idl b/ppapi/api/private/ppb_tcp_server_socket_private.idl
index f04635c..a9130cc 100644
--- a/ppapi/api/private/ppb_tcp_server_socket_private.idl
+++ b/ppapi/api/private/ppb_tcp_server_socket_private.idl
@@ -8,7 +8,8 @@
  */
 
 label Chrome {
-  M18 = 0.1
+  M18 = 0.1,
+  M28 = 0.2
 };
 
 /**
@@ -53,6 +54,15 @@ interface PPB_TCPServerSocket_Private {
                  [in] PP_CompletionCallback callback);
 
   /**
+   * Returns the current address to which the socket is bound, in the
+   * buffer pointed to by |addr|. This method can be called only after
+   * successful Listen() call and before StopListening() call.
+   */
+  [version=0.2]
+  int32_t GetLocalAddress([in] PP_Resource tcp_server_socket,
+                          [out] PP_NetAddress_Private addr);
+
+  /**
    * Cancels all pending callbacks reporting PP_ERROR_ABORTED and
    * closes the socket. Note: this method is implicitly called when
    * server socket is destroyed.
diff --git a/ppapi/c/private/ppb_tcp_server_socket_private.h b/ppapi/c/private/ppb_tcp_server_socket_private.h
index f019519..7de387b 100644
--- a/ppapi/c/private/ppb_tcp_server_socket_private.h
+++ b/ppapi/c/private/ppb_tcp_server_socket_private.h
@@ -4,7 +4,7 @@
  */
 
 /* From private/ppb_tcp_server_socket_private.idl,
- *   modified Thu Mar 28 10:31:11 2013.
+ *   modified Mon May 20 12:45:38 2013.
  */
 
 #ifndef PPAPI_C_PRIVATE_PPB_TCP_SERVER_SOCKET_PRIVATE_H_
@@ -20,8 +20,10 @@
 
 #define PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_1 \
     "PPB_TCPServerSocket_Private;0.1"
+#define PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_2 \
+    "PPB_TCPServerSocket_Private;0.2"
 #define PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE \
-    PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_1
+    PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_2
 
 /**
  * @file
@@ -37,7 +39,7 @@
  * The <code>PPB_TCPServerSocket_Private</code> interface provides TCP
  * server socket operations.
  */
-struct PPB_TCPServerSocket_Private_0_1 {
+struct PPB_TCPServerSocket_Private_0_2 {
   /**
    * Allocates a TCP server socket resource.
    */
@@ -71,6 +73,13 @@ struct PPB_TCPServerSocket_Private_0_1 {
                     PP_Resource* tcp_socket,
                     struct PP_CompletionCallback callback);
   /**
+   * Returns the current address to which the socket is bound, in the
+   * buffer pointed to by |addr|. This method can be called only after
+   * successful Listen() call and before StopListening() call.
+   */
+  int32_t (*GetLocalAddress)(PP_Resource tcp_server_socket,
+                             struct PP_NetAddress_Private* addr);
+  /**
    * Cancels all pending callbacks reporting PP_ERROR_ABORTED and
    * closes the socket. Note: this method is implicitly called when
    * server socket is destroyed.
@@ -78,7 +87,20 @@ struct PPB_TCPServerSocket_Private_0_1 {
   void (*StopListening)(PP_Resource tcp_server_socket);
 };
 
-typedef struct PPB_TCPServerSocket_Private_0_1 PPB_TCPServerSocket_Private;
+typedef struct PPB_TCPServerSocket_Private_0_2 PPB_TCPServerSocket_Private;
+
+struct PPB_TCPServerSocket_Private_0_1 {
+  PP_Resource (*Create)(PP_Instance instance);
+  PP_Bool (*IsTCPServerSocket)(PP_Resource resource);
+  int32_t (*Listen)(PP_Resource tcp_server_socket,
+                    const struct PP_NetAddress_Private* addr,
+                    int32_t backlog,
+                    struct PP_CompletionCallback callback);
+  int32_t (*Accept)(PP_Resource tcp_server_socket,
+                    PP_Resource* tcp_socket,
+                    struct PP_CompletionCallback callback);
+  void (*StopListening)(PP_Resource tcp_server_socket);
+};
 /**
  * @}
  */
diff --git a/ppapi/cpp/private/tcp_server_socket_private.cc b/ppapi/cpp/private/tcp_server_socket_private.cc
index 5f315bf..50adcc1 100644
--- a/ppapi/cpp/private/tcp_server_socket_private.cc
+++ b/ppapi/cpp/private/tcp_server_socket_private.cc
@@ -14,46 +14,78 @@ namespace pp {
 
 namespace {
 
-template <> const char* interface_name<PPB_TCPServerSocket_Private>() {
-  return PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE;
+template <> const char* interface_name<PPB_TCPServerSocket_Private_0_2>() {
+  return PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_2;
+}
+
+template <> const char* interface_name<PPB_TCPServerSocket_Private_0_1>() {
+  return PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_1;
 }
 
 }  // namespace
 
 TCPServerSocketPrivate::TCPServerSocketPrivate(const InstanceHandle& instance) {
-  if (has_interface<PPB_TCPServerSocket_Private>()) {
-    PassRefFromConstructor(get_interface<PPB_TCPServerSocket_Private>()->Create(
-        instance.pp_instance()));
+  if (has_interface<PPB_TCPServerSocket_Private_0_2>()) {
+    PassRefFromConstructor(
+        get_interface<PPB_TCPServerSocket_Private_0_2>()->Create(
+            instance.pp_instance()));
+  } else if (has_interface<PPB_TCPServerSocket_Private_0_1>()) {
+    PassRefFromConstructor(
+        get_interface<PPB_TCPServerSocket_Private_0_1>()->Create(
+            instance.pp_instance()));
   }
 }
 
 // static
 bool TCPServerSocketPrivate::IsAvailable() {
-  return has_interface<PPB_TCPServerSocket_Private>();
+  return has_interface<PPB_TCPServerSocket_Private_0_2>() ||
+      has_interface<PPB_TCPServerSocket_Private_0_1>();
 }
 
 int32_t TCPServerSocketPrivate::Listen(const PP_NetAddress_Private* addr,
                                        int32_t backlog,
                                        const CompletionCallback& callback) {
-  if (!has_interface<PPB_TCPServerSocket_Private>())
-    return callback.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_TCPServerSocket_Private>()->Listen(
-      pp_resource(), addr, backlog, callback.pp_completion_callback());
+  if (has_interface<PPB_TCPServerSocket_Private_0_2>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_2>()->Listen(
+        pp_resource(), addr, backlog, callback.pp_completion_callback());
+  }
+  if (has_interface<PPB_TCPServerSocket_Private_0_1>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_1>()->Listen(
+        pp_resource(), addr, backlog, callback.pp_completion_callback());
+  }
+  return callback.MayForce(PP_ERROR_NOINTERFACE);
 }
 
 int32_t TCPServerSocketPrivate::Accept(PP_Resource* tcp_socket,
                                        const CompletionCallback& callback) {
-  if (!has_interface<PPB_TCPServerSocket_Private>())
-    return callback.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_TCPServerSocket_Private>()->Accept(
-      pp_resource(), tcp_socket, callback.pp_completion_callback());
+  if (has_interface<PPB_TCPServerSocket_Private_0_2>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_2>()->Accept(
+        pp_resource(), tcp_socket, callback.pp_completion_callback());
+  }
+  if (has_interface<PPB_TCPServerSocket_Private_0_1>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_1>()->Accept(
+        pp_resource(), tcp_socket, callback.pp_completion_callback());
+  }
+  return callback.MayForce(PP_ERROR_NOINTERFACE);
+}
+
+int32_t TCPServerSocketPrivate::GetLocalAddress(PP_NetAddress_Private* addr) {
+  if (has_interface<PPB_TCPServerSocket_Private_0_2>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_2>()->GetLocalAddress(
+        pp_resource(), addr);
+  }
+  return PP_ERROR_NOINTERFACE;
 }
 
 void TCPServerSocketPrivate::StopListening() {
-  if (!has_interface<PPB_TCPServerSocket_Private>())
-    return;
-  return get_interface<PPB_TCPServerSocket_Private>()->StopListening(
-      pp_resource());
+  if (has_interface<PPB_TCPServerSocket_Private_0_2>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_2>()->StopListening(
+        pp_resource());
+  }
+  if (has_interface<PPB_TCPServerSocket_Private_0_1>()) {
+    return get_interface<PPB_TCPServerSocket_Private_0_1>()->StopListening(
+        pp_resource());
+  }
 }
 
 }  // namespace pp
diff --git a/ppapi/cpp/private/tcp_server_socket_private.h b/ppapi/cpp/private/tcp_server_socket_private.h
index 3d40cea..d6a1942 100644
--- a/ppapi/cpp/private/tcp_server_socket_private.h
+++ b/ppapi/cpp/private/tcp_server_socket_private.h
@@ -30,6 +30,7 @@ class TCPServerSocketPrivate : public Resource {
   // |callback| is called or StopListening method is called.
   int32_t Accept(PP_Resource* socket,
                  const CompletionCallback& callback);
+  int32_t GetLocalAddress(PP_NetAddress_Private* addr);
   void StopListening();
 };
 
diff --git a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
index fe06f54..7d93dda57 100644
--- a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
+++ b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
@@ -262,6 +262,7 @@ static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_NetworkList_Private_0_2;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_NetworkMonitor_Private_0_2;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_Talk_Private_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_1;
+static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_3;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_4;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_5;
@@ -2990,6 +2991,40 @@ static void Pnacl_M18_PPB_TCPServerSocket_Private_StopListening(PP_Resource tcp_
 
 /* End wrapper methods for PPB_TCPServerSocket_Private_0_1 */
 
+/* Begin wrapper methods for PPB_TCPServerSocket_Private_0_2 */
+
+static PP_Resource Pnacl_M28_PPB_TCPServerSocket_Private_Create(PP_Instance instance) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  return iface->Create(instance);
+}
+
+static PP_Bool Pnacl_M28_PPB_TCPServerSocket_Private_IsTCPServerSocket(PP_Resource resource) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  return iface->IsTCPServerSocket(resource);
+}
+
+static int32_t Pnacl_M28_PPB_TCPServerSocket_Private_Listen(PP_Resource tcp_server_socket, const struct PP_NetAddress_Private* addr, int32_t backlog, struct PP_CompletionCallback* callback) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  return iface->Listen(tcp_server_socket, addr, backlog, *callback);
+}
+
+static int32_t Pnacl_M28_PPB_TCPServerSocket_Private_Accept(PP_Resource tcp_server_socket, PP_Resource* tcp_socket, struct PP_CompletionCallback* callback) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  return iface->Accept(tcp_server_socket, tcp_socket, *callback);
+}
+
+static int32_t Pnacl_M28_PPB_TCPServerSocket_Private_GetLocalAddress(PP_Resource tcp_server_socket, struct PP_NetAddress_Private* addr) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  return iface->GetLocalAddress(tcp_server_socket, addr);
+}
+
+static void Pnacl_M28_PPB_TCPServerSocket_Private_StopListening(PP_Resource tcp_server_socket) {
+  const struct PPB_TCPServerSocket_Private_0_2 *iface = Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2.real_iface;
+  iface->StopListening(tcp_server_socket);
+}
+
+/* End wrapper methods for PPB_TCPServerSocket_Private_0_2 */
+
 /* Begin wrapper methods for PPB_TCPSocket_Private_0_3 */
 
 static PP_Resource Pnacl_M17_PPB_TCPSocket_Private_Create(PP_Instance instance) {
@@ -4413,6 +4448,15 @@ struct PPB_TCPServerSocket_Private_0_1 Pnacl_Wrappers_PPB_TCPServerSocket_Privat
     .StopListening = (void (*)(PP_Resource tcp_server_socket))&Pnacl_M18_PPB_TCPServerSocket_Private_StopListening
 };
 
+struct PPB_TCPServerSocket_Private_0_2 Pnacl_Wrappers_PPB_TCPServerSocket_Private_0_2 = {
+    .Create = (PP_Resource (*)(PP_Instance instance))&Pnacl_M28_PPB_TCPServerSocket_Private_Create,
+    .IsTCPServerSocket = (PP_Bool (*)(PP_Resource resource))&Pnacl_M28_PPB_TCPServerSocket_Private_IsTCPServerSocket,
+    .Listen = (int32_t (*)(PP_Resource tcp_server_socket, const struct PP_NetAddress_Private* addr, int32_t backlog, struct PP_CompletionCallback callback))&Pnacl_M28_PPB_TCPServerSocket_Private_Listen,
+    .Accept = (int32_t (*)(PP_Resource tcp_server_socket, PP_Resource* tcp_socket, struct PP_CompletionCallback callback))&Pnacl_M28_PPB_TCPServerSocket_Private_Accept,
+    .GetLocalAddress = (int32_t (*)(PP_Resource tcp_server_socket, struct PP_NetAddress_Private* addr))&Pnacl_M28_PPB_TCPServerSocket_Private_GetLocalAddress,
+    .StopListening = (void (*)(PP_Resource tcp_server_socket))&Pnacl_M28_PPB_TCPServerSocket_Private_StopListening
+};
+
 struct PPB_TCPSocket_Private_0_3 Pnacl_Wrappers_PPB_TCPSocket_Private_0_3 = {
     .Create = (PP_Resource (*)(PP_Instance instance))&Pnacl_M17_PPB_TCPSocket_Private_Create,
     .IsTCPSocket = (PP_Bool (*)(PP_Resource resource))&Pnacl_M17_PPB_TCPSocket_Private_IsTCPSocket,
@@ -5358,6 +5402,12 @@ static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0
   .real_iface = NULL
 };
 
+static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2 = {
+  .iface_macro = PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_2,
+  .wrapped_iface = (void *) &Pnacl_Wrappers_PPB_TCPServerSocket_Private_0_2,
+  .real_iface = NULL
+};
+
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_3 = {
   .iface_macro = PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3,
   .wrapped_iface = (void *) &Pnacl_Wrappers_PPB_TCPSocket_Private_0_3,
@@ -5580,6 +5630,7 @@ static struct __PnaclWrapperInfo *s_ppb_wrappers[] = {
   &Pnacl_WrapperInfo_PPB_NetworkMonitor_Private_0_2,
   &Pnacl_WrapperInfo_PPB_Talk_Private_1_0,
   &Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_1,
+  &Pnacl_WrapperInfo_PPB_TCPServerSocket_Private_0_2,
   &Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_3,
   &Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_4,
   &Pnacl_WrapperInfo_PPB_TCPSocket_Private_0_5,
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 6aaaabc..48a10fd 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -719,10 +719,11 @@ IPC_MESSAGE_ROUTED3(PpapiMsg_PPBTCPSocket_SetBoolOptionACK,
 // initialized (if needed) but Listen call is failed.
 // |status| == PP_OK means that socket is correctly initialized (if
 // needed) and Listen call succeeds.
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBTCPServerSocket_ListenACK,
+IPC_MESSAGE_ROUTED5(PpapiMsg_PPBTCPServerSocket_ListenACK,
                     uint32 /* plugin_dispatcher_id */,
                     PP_Resource /* socket_resource */,
                     uint32 /* socket_id */,
+                    PP_NetAddress_Private /* local_addr */,
                     int32_t /* status */)
 IPC_MESSAGE_ROUTED5(PpapiMsg_PPBTCPServerSocket_AcceptACK,
                     uint32 /* plugin_dispatcher_id */,
diff --git a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
index e577a6b..f895aac 100644
--- a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
+++ b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
@@ -158,15 +158,16 @@ void PPB_TCPServerSocket_Private_Proxy::OnMsgListenACK(
     uint32 plugin_dispatcher_id,
     PP_Resource socket_resource,
     uint32 socket_id,
+    const PP_NetAddress_Private& local_addr,
     int32_t status) {
- thunk::EnterResourceNoLock<thunk::PPB_TCPServerSocket_Private_API>
+  thunk::EnterResourceNoLock<thunk::PPB_TCPServerSocket_Private_API>
      enter(socket_resource, true);
   if (enter.succeeded()) {
     PPB_TCPServerSocket_Shared* server_socket =
         static_cast<PPB_TCPServerSocket_Shared*>(enter.object());
     if (status == PP_OK)
       id_to_server_socket_[socket_id] = server_socket;
-    server_socket->OnListenCompleted(socket_id, status);
+    server_socket->OnListenCompleted(socket_id, local_addr, status);
   } else if (socket_id != 0 && status == PP_OK) {
     IPC::Message* msg =
         new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id);
diff --git a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.h b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.h
index e2e644f..3fd985e 100644
--- a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.h
+++ b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.h
@@ -41,6 +41,7 @@ class PPB_TCPServerSocket_Private_Proxy : public InterfaceProxy {
   void OnMsgListenACK(uint32 plugin_dispatcher_id,
                       PP_Resource socket_resource,
                       uint32 socket_id,
+                      const PP_NetAddress_Private& local_addr,
                       int32_t status);
   void OnMsgAcceptACK(uint32 plugin_dispatcher_id,
                       uint32 server_socket_id,
diff --git a/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.cc b/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.cc
index f816c62..11add89 100644
--- a/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.cc
+++ b/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.cc
@@ -5,15 +5,18 @@
 #include "ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h"
 
 #include <cstddef>
+#include <cstring>
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/private/net_address_private_impl.h"
 
 namespace ppapi {
 
 PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(PP_Instance instance)
     : Resource(OBJECT_IS_IMPL, instance),
       socket_id_(0),
+      local_addr_(),
       state_(BEFORE_LISTENING),
       tcp_socket_buffer_(NULL) {
 }
@@ -22,6 +25,7 @@ PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(
     const HostResource& resource)
     : Resource(OBJECT_IS_PROXY, resource),
       socket_id_(0),
+      local_addr_(),
       state_(BEFORE_LISTENING),
       tcp_socket_buffer_(NULL) {
 }
@@ -69,6 +73,16 @@ int32_t PPB_TCPServerSocket_Shared::Accept(
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t PPB_TCPServerSocket_Shared::GetLocalAddress(
+    PP_NetAddress_Private* addr) {
+  if (!addr)
+    return PP_ERROR_BADARGUMENT;
+  if (state_ != LISTENING)
+    return PP_ERROR_FAILED;
+  *addr = local_addr_;
+  return PP_OK;
+}
+
 void PPB_TCPServerSocket_Shared::StopListening() {
   if (state_ == CLOSED)
     return;
@@ -85,8 +99,10 @@ void PPB_TCPServerSocket_Shared::StopListening() {
   tcp_socket_buffer_ = NULL;
 }
 
-void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 socket_id,
-                                                   int32_t status) {
+void PPB_TCPServerSocket_Shared::OnListenCompleted(
+    uint32 socket_id,
+    const PP_NetAddress_Private& local_addr,
+    int32_t status) {
   if (state_ != BEFORE_LISTENING ||
       !TrackedCallback::IsPending(listen_callback_)) {
     NOTREACHED();
@@ -95,6 +111,7 @@ void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 socket_id,
 
   if (status == PP_OK) {
     socket_id_ = socket_id;
+    local_addr_ = local_addr;
     state_ = LISTENING;
   }
 
diff --git a/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h b/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h
index 03c22ab..29d14a2 100644
--- a/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h
+++ b/ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h
@@ -38,9 +38,12 @@ class PPAPI_SHARED_EXPORT PPB_TCPServerSocket_Shared
                          scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Accept(PP_Resource* tcp_socket,
                          scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t GetLocalAddress(PP_NetAddress_Private* addr) OVERRIDE;
   virtual void StopListening() OVERRIDE;
 
-  void OnListenCompleted(uint32 socket_id, int32_t status);
+  void OnListenCompleted(uint32 socket_id,
+                         const PP_NetAddress_Private& local_addr,
+                         int32_t status);
   virtual void OnAcceptCompleted(bool succeeded,
                                  uint32 accepted_socket_id,
                                  const PP_NetAddress_Private& local_addr,
@@ -65,6 +68,7 @@ class PPAPI_SHARED_EXPORT PPB_TCPServerSocket_Shared
   };
 
   uint32 socket_id_;
+  PP_NetAddress_Private local_addr_;
   State state_;
 
   scoped_refptr<TrackedCallback> listen_callback_;
diff --git a/ppapi/tests/test_tcp_server_socket_private.cc b/ppapi/tests/test_tcp_server_socket_private.cc
index 47e3020..880515d 100644
--- a/ppapi/tests/test_tcp_server_socket_private.cc
+++ b/ppapi/tests/test_tcp_server_socket_private.cc
@@ -4,6 +4,7 @@
 
 #include "ppapi/tests/test_tcp_server_socket_private.h"
 
+#include <cstdio>
 #include <vector>
 
 #include "ppapi/cpp/pass_ref.h"
@@ -132,25 +133,16 @@ std::string TestTCPServerSocketPrivate::SyncListen(
     int32_t backlog) {
   PP_NetAddress_Private base_address;
   ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address));
-
-  // TODO (ygorshenin): find more efficient way to select available
-  // ports.
-  bool is_free_port_found = false;
-  for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
-    if (!NetAddressPrivate::ReplacePort(base_address, port, address))
-      return ReportError("PPB_NetAddress_Private::ReplacePort", 0);
-
-    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
-    callback.WaitForResult(
-        socket->Listen(address, backlog, callback.GetCallback()));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback.result() == PP_OK) {
-      is_free_port_found = true;
-      break;
-    }
-  }
-
-  ASSERT_TRUE(is_free_port_found);
+  if (!NetAddressPrivate::ReplacePort(base_address, 0, address))
+    return ReportError("PPB_NetAddress_Private::ReplacePort", 0);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->Listen(address, backlog, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = socket->GetLocalAddress(address);
+  ASSERT_EQ(PP_OK, rv);
+  ASSERT_TRUE(NetAddressPrivate::GetPort(*address) != 0);
   PASS();
 }
 
@@ -158,14 +150,12 @@ std::string TestTCPServerSocketPrivate::TestListen() {
   static const int kBacklog = 2;
 
   TCPServerSocketPrivate server_socket(instance_);
-
   PP_NetAddress_Private address;
   ASSERT_SUBTEST_SUCCESS(SyncListen(&server_socket, &address, kBacklog));
 
   // We can't use a blocking callback for Accept, because it will wait forever
   // for the client to connect, since the client connects after.
-  TestCompletionCallback accept_callback(instance_->pp_instance(),
-                                         PP_REQUIRED);
+  TestCompletionCallback accept_callback(instance_->pp_instance(), PP_REQUIRED);
   // We need to make sure there's a message loop to run accept_callback on.
   pp::MessageLoop current_thread_loop(pp::MessageLoop::GetCurrent());
   if (current_thread_loop.is_null() && testing_interface_->IsOutOfProcess()) {
@@ -209,7 +199,6 @@ std::string TestTCPServerSocketPrivate::TestBacklog() {
   static const size_t kBacklog = 5;
 
   TCPServerSocketPrivate server_socket(instance_);
-
   PP_NetAddress_Private address;
   ASSERT_SUBTEST_SUCCESS(SyncListen(&server_socket, &address, 2 * kBacklog));
 
diff --git a/ppapi/tests/test_tcp_server_socket_private_disallowed.cc b/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
index 8c89a3a..99aceb1 100644
--- a/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
+++ b/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
@@ -62,22 +62,17 @@ std::string TestTCPServerSocketPrivateDisallowed::TestListen() {
   ASSERT_TRUE(socket != 0);
   ASSERT_TRUE(tcp_server_socket_private_interface_->IsTCPServerSocket(socket));
 
-  PP_NetAddress_Private base_address, current_address;
+  PP_NetAddress_Private base_address, address;
   pp::NetAddressPrivate::GetAnyAddress(false, &base_address);
-
-  for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
-    ASSERT_TRUE(pp::NetAddressPrivate::ReplacePort(base_address,
-                                                   port,
-                                                   &current_address));
-    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
-    callback.WaitForResult(tcp_server_socket_private_interface_->Listen(
-        socket,
-        &current_address,
-        1,
-        callback.GetCallback().pp_completion_callback()));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_NE(PP_OK, callback.result());
-  }
-
+  ASSERT_TRUE(pp::NetAddressPrivate::ReplacePort(
+      base_address, 0, &address));
+  TestCompletionCallback callback(instance_->pp_instance());
+  callback.WaitForResult(tcp_server_socket_private_interface_->Listen(
+      socket,
+      &address,
+      1,
+      callback.GetCallback().pp_completion_callback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_NE(PP_OK, callback.result());
   PASS();
 }
diff --git a/ppapi/thunk/interfaces_ppb_private_no_permissions.h b/ppapi/thunk/interfaces_ppb_private_no_permissions.h
index 138ce9c..dca6289 100644
--- a/ppapi/thunk/interfaces_ppb_private_no_permissions.h
+++ b/ppapi/thunk/interfaces_ppb_private_no_permissions.h
@@ -19,6 +19,9 @@ PROXIED_IFACE(NoAPIName, PPB_HOSTRESOLVER_PRIVATE_INTERFACE_0_1,
 PROXIED_IFACE(PPB_TCPServerSocket_Private,
               PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_1,
               PPB_TCPServerSocket_Private_0_1)
+PROXIED_IFACE(PPB_TCPServerSocket_Private,
+              PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_2,
+              PPB_TCPServerSocket_Private_0_2)
 PROXIED_IFACE(PPB_TCPSocket_Private, PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3,
               PPB_TCPSocket_Private_0_3)
 PROXIED_IFACE(PPB_TCPSocket_Private, PPB_TCPSOCKET_PRIVATE_INTERFACE_0_4,
diff --git a/ppapi/thunk/ppb_tcp_server_socket_private_api.h b/ppapi/thunk/ppb_tcp_server_socket_private_api.h
index 8563bef..0ca23d1 100644
--- a/ppapi/thunk/ppb_tcp_server_socket_private_api.h
+++ b/ppapi/thunk/ppb_tcp_server_socket_private_api.h
@@ -24,6 +24,7 @@ public:
                          scoped_refptr<TrackedCallback> callback) = 0;
   virtual int32_t Accept(PP_Resource* tcp_socket,
                          scoped_refptr<TrackedCallback> callback) = 0;
+  virtual int32_t GetLocalAddress(PP_NetAddress_Private* addr) = 0;
   virtual void StopListening() = 0;
 };
 
diff --git a/ppapi/thunk/ppb_tcp_server_socket_private_thunk.cc b/ppapi/thunk/ppb_tcp_server_socket_private_thunk.cc
index a9fcb14..bbfe16d 100644
--- a/ppapi/thunk/ppb_tcp_server_socket_private_thunk.cc
+++ b/ppapi/thunk/ppb_tcp_server_socket_private_thunk.cc
@@ -49,13 +49,21 @@ int32_t Accept(PP_Resource tcp_server_socket,
   return enter.SetResult(enter.object()->Accept(tcp_socket, enter.callback()));
 }
 
+int32_t GetLocalAddress(PP_Resource tcp_server_socket,
+                        PP_NetAddress_Private* addr) {
+  EnterTCPServer enter(tcp_server_socket, true);
+  if (enter.failed())
+    return PP_ERROR_BADRESOURCE;
+  return enter.object()->GetLocalAddress(addr);
+}
+
 void StopListening(PP_Resource tcp_server_socket) {
   EnterTCPServer enter(tcp_server_socket, true);
   if (enter.succeeded())
     enter.object()->StopListening();
 }
 
-const PPB_TCPServerSocket_Private g_ppb_tcp_server_socket_thunk = {
+const PPB_TCPServerSocket_Private_0_1 g_ppb_tcp_server_socket_thunk_0_1 = {
   Create,
   IsTCPServerSocket,
   Listen,
@@ -63,10 +71,25 @@ const PPB_TCPServerSocket_Private g_ppb_tcp_server_socket_thunk = {
   StopListening
 };
 
+const PPB_TCPServerSocket_Private_0_2 g_ppb_tcp_server_socket_thunk_0_2 = {
+  Create,
+  IsTCPServerSocket,
+  Listen,
+  Accept,
+  GetLocalAddress,
+  StopListening,
+};
+
 }  // namespace
 
-const PPB_TCPServerSocket_Private* GetPPB_TCPServerSocket_Private_0_1_Thunk() {
-  return &g_ppb_tcp_server_socket_thunk;
+const PPB_TCPServerSocket_Private_0_1*
+GetPPB_TCPServerSocket_Private_0_1_Thunk() {
+  return &g_ppb_tcp_server_socket_thunk_0_1;
+}
+
+const PPB_TCPServerSocket_Private_0_2*
+GetPPB_TCPServerSocket_Private_0_2_Thunk() {
+  return &g_ppb_tcp_server_socket_thunk_0_2;
 }
 
 }  // namespace thunk