Make the Pepper Flash net address just private, not Flash-specific.

ppapi/proxy/ppb_flash_udp_socket_proxy.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/proxy/ppb_flash_udp_socket_proxy.h"
 
 #include <algorithm>
 #include <cstring>
 #include <map>
 
@@ skipping 41 matching lines @@
 class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
                        public Resource {
  public:
   FlashUDPSocket(const HostResource& resource, uint32 socket_id);
   virtual ~FlashUDPSocket();
 
   // ResourceObjectBase overrides.
   virtual PPB_Flash_UDPSocket_API* AsPPB_Flash_UDPSocket_API() OVERRIDE;
 
   // PPB_Flash_UDPSocket_API implementation.
-  virtual int32_t Bind(const PP_Flash_NetAddress* addr,
+  virtual int32_t Bind(const PP_NetAddress_Private* addr,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t RecvFrom(char* buffer,
                            int32_t num_bytes,
                            PP_CompletionCallback callback) OVERRIDE;
-  virtual PP_Bool GetRecvFromAddress(PP_Flash_NetAddress* addr) OVERRIDE;
+  virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) OVERRIDE;
 
   virtual int32_t SendTo(const char* buffer,
                          int32_t num_bytes,
-                         const PP_Flash_NetAddress* addr,
+                         const PP_NetAddress_Private* addr,
                          PP_CompletionCallback callback) OVERRIDE;
   virtual void Close() OVERRIDE;
 
   // Notifications from the proxy.
   void OnBindCompleted(bool succeeded);
   void OnRecvFromCompleted(bool succeeded,
                            const std::string& data,
-                           const PP_Flash_NetAddress& addr);
+                           const PP_NetAddress_Private& addr);
   void OnSendToCompleted(bool succeeded,
                          int32_t bytes_written);
 
  private:
   void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback);
 
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
   }
 
   uint32 socket_id_;
 
   bool binded_;
   bool closed_;
 
   PP_CompletionCallback bind_callback_;
   PP_CompletionCallback recvfrom_callback_;
   PP_CompletionCallback sendto_callback_;
 
   char* read_buffer_;
   int32_t bytes_to_read_;
 
-  PP_Flash_NetAddress recvfrom_addr_;
+  PP_NetAddress_Private recvfrom_addr_;
 
   DISALLOW_COPY_AND_ASSIGN(FlashUDPSocket);
 };
 
 FlashUDPSocket::FlashUDPSocket(const HostResource& resource,
                                uint32 socket_id)
     : Resource(resource),
       socket_id_(socket_id),
       binded_(false),
       closed_(false),
@@ skipping 14 matching lines @@
 }
 
 FlashUDPSocket::~FlashUDPSocket() {
   Close();
 }
 
 PPB_Flash_UDPSocket_API* FlashUDPSocket::AsPPB_Flash_UDPSocket_API() {
   return this;
 }
 
-int32_t FlashUDPSocket::Bind(const PP_Flash_NetAddress* addr,
+int32_t FlashUDPSocket::Bind(const PP_NetAddress_Private* addr,
                              PP_CompletionCallback callback) {
   if (!addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
   if (binded_ || closed_)
     return PP_ERROR_FAILED;
   if (bind_callback_.func)
     return PP_ERROR_INPROGRESS;
 
   bind_callback_ = callback;
 
@@ skipping 17 matching lines @@
   bytes_to_read_ = std::min(num_bytes, kFlashUDPSocketMaxReadSize);
   recvfrom_callback_ = callback;
 
   // Send the request, the browser will call us back via RecvFromACK.
   GetDispatcher()->SendToBrowser(
       new PpapiHostMsg_PPBFlashUDPSocket_RecvFrom(
           socket_id_, num_bytes));
   return PP_OK_COMPLETIONPENDING;
 }
 
-PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_Flash_NetAddress* addr) {
+PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
 
   *addr = recvfrom_addr_;
   return PP_TRUE;
 }
 
 int32_t FlashUDPSocket::SendTo(const char* buffer,
                                int32_t num_bytes,
-                               const PP_Flash_NetAddress* addr,
+                               const PP_NetAddress_Private* addr,
                                PP_CompletionCallback callback) {
   if (!buffer || num_bytes <= 0 || !addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
   if (!binded_)
     return PP_ERROR_FAILED;
   if (sendto_callback_.func)
     return PP_ERROR_INPROGRESS;
 
   if (num_bytes > kFlashUDPSocketMaxWriteSize)
     num_bytes = kFlashUDPSocketMaxWriteSize;
@@ skipping 37 matching lines @@
 
   if (succeeded)
     binded_ = true;
 
   PP_RunAndClearCompletionCallback(&bind_callback_,
                                    succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
 void FlashUDPSocket::OnRecvFromCompleted(bool succeeded,
                                          const std::string& data,
-                                         const PP_Flash_NetAddress& addr) {
+                                         const PP_NetAddress_Private& addr) {
   if (!recvfrom_callback_.func || !read_buffer_) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
     CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
     if (!data.empty())
       memcpy(read_buffer_, data.c_str(), data.size());
   }
@@ skipping 82 matching lines @@
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnBindCompleted(succeeded);
 }
 
 void PPB_Flash_UDPSocket_Proxy::OnMsgRecvFromACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnRecvFromCompleted(succeeded, data, addr);
 }
 
 void PPB_Flash_UDPSocket_Proxy::OnMsgSendToACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
     int32_t bytes_written) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnSendToCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace ppapi
-