Snapshot of all changes to get jumbo in blink and content.

content/browser/renderer_host/p2p/socket_host_udp.cc

 // Copyright (c) 2012 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/p2p/socket_host_udp.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/p2p/socket_host_throttler.h"
 #include "content/common/p2p_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "third_party/webrtc/media/base/rtputils.h"
 
 namespace {
 
 // UDP packets cannot be bigger than 64k.
-const int kReadBufferSize = 65536;
+const int kUDPReadBufferSize = 65536;
 // Socket receive buffer size.
-const int kRecvSocketBufferSize = 65536;  // 64K
+const int kUDPRecvSocketBufferSize = 65536;  // 64K
 
 // Defines set of transient errors. These errors are ignored when we get them
 // from sendto() or recvfrom() calls.
 //
 // net::ERR_OUT_OF_MEMORY
 //
 // This is caused by ENOBUFS which means the buffer of the network interface
 // is full.
 //
 // net::ERR_CONNECTION_RESET
@@ skipping 122 matching lines @@
                << (min_port == 0
                        ? base::StringPrintf(":%d", local_address.port())
                        : base::StringPrintf(", port range [%d-%d]", min_port,
                                             max_port))
                << " failed: " << result;
     OnError();
     return false;
   }
 
   // Setting recv socket buffer size.
-  if (socket_->SetReceiveBufferSize(kRecvSocketBufferSize) != net::OK) {
+  if (socket_->SetReceiveBufferSize(kUDPRecvSocketBufferSize) != net::OK) {
     LOG(WARNING) << "Failed to set socket receive buffer size to "
-                 << kRecvSocketBufferSize;
+                 << kUDPRecvSocketBufferSize;
   }
 
   net::IPEndPoint address;
   result = socket_->GetLocalAddress(&address);
   if (result < 0) {
     LOG(ERROR) << "P2PSocketHostUdp::Init(): unable to get local address: "
                << result;
     OnError();
     return false;
   }
   VLOG(1) << "Local address: " << address.ToString();
 
   state_ = STATE_OPEN;
 
   SetSendBufferSize();
 
   // NOTE: Remote address will be same as what renderer provided.
   message_sender_->Send(new P2PMsg_OnSocketCreated(
       id_, address, remote_address.ip_address));
 
-  recv_buffer_ = new net::IOBuffer(kReadBufferSize);
+  recv_buffer_ = new net::IOBuffer(kUDPReadBufferSize);
   DoRead();
 
   return true;
 }
 
 void P2PSocketHostUdp::OnError() {
   socket_.reset();
   send_queue_.clear();
 
   if (state_ == STATE_UNINITIALIZED || state_ == STATE_OPEN)
     message_sender_->Send(new P2PMsg_OnError(id_));
 
   state_ = STATE_ERROR;
 }
 
 void P2PSocketHostUdp::DoRead() {
   int result;
   do {
     result = socket_->RecvFrom(
         recv_buffer_.get(),
-        kReadBufferSize,
+        kUDPReadBufferSize,
         &recv_address_,
         base::Bind(&P2PSocketHostUdp::OnRecv, base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       return;
     HandleReadResult(result);
   } while (state_ == STATE_OPEN);
 }
 
 void P2PSocketHostUdp::OnRecv(int result) {
   HandleReadResult(result);
@@ skipping 223 matching lines @@
   net::UDPServerSocket* socket = new net::UDPServerSocket(
       GetContentClient()->browser()->GetNetLog(), net::NetLogSource());
 #if defined(OS_WIN)
   socket->UseNonBlockingIO();
 #endif
 
   return base::WrapUnique(socket);
 }
 
 }  // namespace content