Make ppapi/proxy child-process only

ppapi/proxy/tcp_socket_resource_base.cc

 // Copyright 2013 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/tcp_socket_resource_base.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/error_conversion.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/tcp_socket_resource_constants.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/private/ppb_x509_certificate_private_shared.h"
 #include "ppapi/shared_impl/socket_option_data.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_x509_certificate_private_api.h"
 
 namespace ppapi {
 namespace proxy {
 
-const int32_t TCPSocketResourceBase::kMaxReadSize = 1024 * 1024;
-const int32_t TCPSocketResourceBase::kMaxWriteSize = 1024 * 1024;
-const int32_t TCPSocketResourceBase::kMaxSendBufferSize =
-    1024 * TCPSocketResourceBase::kMaxWriteSize;
-const int32_t TCPSocketResourceBase::kMaxReceiveBufferSize =
-    1024 * TCPSocketResourceBase::kMaxReadSize;
-
 TCPSocketResourceBase::TCPSocketResourceBase(Connection connection,
                                              PP_Instance instance,
                                              TCPSocketVersion version)
     : PluginResource(connection, instance),
       state_(TCPSocketState::INITIAL),
       read_buffer_(NULL),
       bytes_to_read_(-1),
       accepted_tcp_socket_(NULL),
       version_(version) {
   local_addr_.size = 0;
@@ skipping 161 matching lines @@
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;
 
   if (!state_.IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(read_callback_) ||
       state_.IsPending(TCPSocketState::SSL_CONNECT))
     return PP_ERROR_INPROGRESS;
   read_buffer_ = buffer;
-  bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);
+  bytes_to_read_ =
+      std::min(bytes_to_read, TCPSocketResourceConstants::kMaxReadSize);
   read_callback_ = callback;
 
   Call<PpapiPluginMsg_TCPSocket_ReadReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Read(bytes_to_read_),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgReadReply,
                  base::Unretained(this)),
       callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::WriteImpl(
     const char* buffer,
     int32_t bytes_to_write,
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_write <= 0)
     return PP_ERROR_BADARGUMENT;
 
   if (!state_.IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(write_callback_) ||
       state_.IsPending(TCPSocketState::SSL_CONNECT))
     return PP_ERROR_INPROGRESS;
 
-  if (bytes_to_write > kMaxWriteSize)
-    bytes_to_write = kMaxWriteSize;
+  if (bytes_to_write > TCPSocketResourceConstants::kMaxWriteSize)
+    bytes_to_write = TCPSocketResourceConstants::kMaxWriteSize;
 
   write_callback_ = callback;
 
   Call<PpapiPluginMsg_TCPSocket_WriteReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Write(std::string(buffer, bytes_to_write)),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgWriteReply,
                  base::Unretained(this)),
       callback);
   return PP_OK_COMPLETIONPENDING;
@@ skipping 252 matching lines @@
 }
 
 void TCPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
                                         int32_t pp_result) {
   callback->Run(ConvertNetworkAPIErrorForCompatibility(
       pp_result, version_ == TCP_SOCKET_VERSION_PRIVATE));
 }
 
 }  // namespace ppapi
 }  // namespace proxy