PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser

content/browser/renderer_host/pepper_tcp_socket.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 "content/browser/renderer_host/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/pepper_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/single_request_host_resolver.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
+#include "ppapi/shared_impl/private/tcp_socket_private_impl.h"
 
 using content::BrowserThread;
 using ppapi::NetAddressPrivateImpl;
 
 PepperTCPSocket::PepperTCPSocket(
     PepperMessageFilter* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 socket_id)
     : manager_(manager),
@@ skipping 91 matching lines @@
 
 void PepperTCPSocket::Read(int32 bytes_to_read) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || end_of_file_reached_ || read_buffer_.get() ||
       bytes_to_read <= 0) {
     SendReadACKError();
     return;
   }
 
-  if (bytes_to_read > ppapi::proxy::kTCPSocketMaxReadSize) {
+  if (bytes_to_read > ppapi::TCPSocketPrivateImpl::kMaxReadSize) {
     NOTREACHED();
-    bytes_to_read = ppapi::proxy::kTCPSocketMaxReadSize;
+    bytes_to_read = ppapi::TCPSocketPrivateImpl::kMaxReadSize;
   }
 
   read_buffer_ = new net::IOBuffer(bytes_to_read);
   int result = socket_->Read(read_buffer_, bytes_to_read, &read_callback_);
   if (result != net::ERR_IO_PENDING)
     OnReadCompleted(result);
 }
 
 void PepperTCPSocket::Write(const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || write_buffer_.get() || data.empty()) {
     SendWriteACKError();
     return;
   }
 
   int data_size = data.size();
-  if (data_size > ppapi::proxy::kTCPSocketMaxWriteSize) {
+  if (data_size > ppapi::TCPSocketPrivateImpl::kMaxWriteSize) {
     NOTREACHED();
-    data_size = ppapi::proxy::kTCPSocketMaxWriteSize;
+    data_size = ppapi::TCPSocketPrivateImpl::kMaxWriteSize;
   }
 
   write_buffer_ = new net::IOBuffer(data_size);
   memcpy(write_buffer_->data(), data.c_str(), data_size);
   int result = socket_->Write(write_buffer_, data.size(), &write_callback_);
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }
 
 void PepperTCPSocket::StartConnect(const net::AddressList& addresses) {
@@ skipping 104 matching lines @@
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   } else {
     SendWriteACKError();
   }
   write_buffer_ = NULL;
 }
 
 bool PepperTCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }