Make ppapi/proxy child-process only

ppapi/proxy/udp_socket_filter.cc

 // Copyright 2015 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/udp_socket_filter.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/error_conversion.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/udp_socket_resource_constants.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace proxy {
 
-const int32_t UDPSocketFilter::kMaxReadSize = 128 * 1024;
-const int32_t UDPSocketFilter::kMaxReceiveBufferSize =
-    1024 * UDPSocketFilter::kMaxReadSize;
-const size_t UDPSocketFilter::kPluginReceiveBufferSlots = 32u;
-
 namespace {
 
 int32_t SetRecvFromOutput(PP_Instance pp_instance,
                           const std::unique_ptr<std::string>& data,
                           const PP_NetAddress_Private& addr,
                           char* output_buffer,
                           int32_t num_bytes,
                           PP_Resource* output_addr,
                           int32_t browser_result) {
   ProxyLock::AssertAcquired();
@@ skipping 111 matching lines @@
 UDPSocketFilter::RecvQueue::~RecvQueue() {
   if (TrackedCallback::IsPending(recvfrom_callback_))
     recvfrom_callback_->PostAbort();
 }
 
 void UDPSocketFilter::RecvQueue::DataReceivedOnIOThread(
     int32_t result,
     const std::string& data,
     const PP_NetAddress_Private& addr) {
   DCHECK(PluginGlobals::Get()->ipc_task_runner()->RunsTasksOnCurrentThread());
-  DCHECK_LT(recv_buffers_.size(), UDPSocketFilter::kPluginReceiveBufferSlots);
+  DCHECK_LT(recv_buffers_.size(),
+            UDPSocketResourceConstants::kPluginReceiveBufferSlots);
 
   if (!TrackedCallback::IsPending(recvfrom_callback_) || !read_buffer_) {
     recv_buffers_.push(RecvBuffer());
     RecvBuffer& back = recv_buffers_.back();
     back.result = result;
     back.data = data;
     back.addr = addr;
     return;
   }
   DCHECK_EQ(recv_buffers_.size(), 0u);
@@ skipping 39 matching lines @@
     PP_Resource* addr_out,
     const scoped_refptr<TrackedCallback>& callback) {
   ProxyLock::AssertAcquired();
   if (!buffer_out || num_bytes <= 0)
     return PP_ERROR_BADARGUMENT;
   if (TrackedCallback::IsPending(recvfrom_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (recv_buffers_.empty()) {
     read_buffer_ = buffer_out;
-    bytes_to_read_ = std::min(num_bytes, UDPSocketFilter::kMaxReadSize);
+    bytes_to_read_ =
+        std::min(num_bytes, UDPSocketResourceConstants::kMaxReadSize);
     recvfrom_addr_resource_ = addr_out;
     recvfrom_callback_ = callback;
     return PP_OK_COMPLETIONPENDING;
   } else {
     RecvBuffer& front = recv_buffers_.front();
 
     if (static_cast<size_t>(num_bytes) < front.data.size())
       return PP_ERROR_MESSAGE_TOO_BIG;
 
     int32_t result = static_cast<int32_t>(front.data.size());
     std::unique_ptr<std::string> data_to_pass(new std::string);
     data_to_pass->swap(front.data);
     SetRecvFromOutput(pp_instance_, std::move(data_to_pass), front.addr,
                       buffer_out, num_bytes, addr_out, PP_OK);
     last_recvfrom_addr_ = front.addr;
     recv_buffers_.pop();
     slot_available_callback_.Run();
 
     return result;
   }
 }
 
 PP_NetAddress_Private UDPSocketFilter::RecvQueue::GetLastAddrPrivate() const {
   CHECK(private_api_);
   return last_recvfrom_addr_;
 }
 
 }  // namespace proxy
 }  // namespace ppapi