Add a new finch experiment to control the system buffer size.

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/debug/trace_event.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.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/base/net_util.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 
@@ skipping 18 matching lines @@
 // last send resulted in an "ICMP Port Unreachable" message.
 bool IsTransientError(int error) {
   return error == net::ERR_ADDRESS_UNREACHABLE ||
          error == net::ERR_ADDRESS_INVALID ||
          error == net::ERR_ACCESS_DENIED ||
          error == net::ERR_CONNECTION_RESET ||
          error == net::ERR_OUT_OF_MEMORY ||
          error == net::ERR_INTERNET_DISCONNECTED;
 }
 
+struct AsyncCallRecord {
+  AsyncCallRecord(uint64 packet_id, uint64 ticks_received) {
+    this->packet_id = packet_id;
+    this->ticks_received = ticks_received;
+  }
+  uint64 packet_id;
+  uint64 ticks_received;
+};
 }  // namespace
 
 namespace content {
 
 P2PSocketHostUdp::PendingPacket::PendingPacket(
     const net::IPEndPoint& to,
     const std::vector<char>& content,
     const rtc::PacketOptions& options,
     uint64 id)
     : to(to),
@@ skipping 19 matching lines @@
       throttler_(throttler) {
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
+void P2PSocketHostUdp::SetSendBufferSize() {
+  unsigned send_buffer_size = 0;

[juberti2, 2014/11/07 22:24:59]

unsigned int

+
+  // In the finch experiment, groups will be named like "2K", "64K",

[juberti2, 2014/11/07 22:24:59]

OOC, would it make more sense to just name the groups "2048", "65535", etc?

+  // etc. The StringToUint will convert the leading number part.
+  if (base::StringToUint(
+          base::FieldTrialList::FindFullName("WebRTC-SystemUDPSendSocketSize"),
+          &send_buffer_size) &&

[Alexei Svitkine (slow), 2014/11/07 22:24:35]

I don't think checking the return value of this function is correct - because I
think it will return false when there's trailing characters. Instead, move it
above the if and just check send_buffer_size > 0.

+      send_buffer_size > 0) {
+    if (!SetOption(P2P_SOCKET_OPT_SNDBUF, send_buffer_size * 1024)) {
+      LOG(WARNING) << "Failed to set socket send buffer size to "
+                   << send_buffer_size * 1024;
+    }
+  }
+}
+
 bool P2PSocketHostUdp::Init(const net::IPEndPoint& local_address,
                             const P2PHostAndIPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   int result = socket_->Listen(local_address);
   if (result < 0) {
     LOG(ERROR) << "bind() failed: " << result;
     OnError();
     return false;
   }
 
   // Setting recv socket buffer size.
   if (socket_->SetReceiveBufferSize(kRecvSocketBufferSize) != net::OK) {
     LOG(WARNING) << "Failed to set socket receive buffer size to "
                  << kRecvSocketBufferSize;
   }
 
   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);
   DoRead();
 
   return true;
 }
 
@@ skipping 112 matching lines @@
     int result = socket_->SetDiffServCodePoint(dscp);
     if (result == net::OK) {
       last_dscp_ = dscp;
     } else if (!IsTransientError(result) && last_dscp_ != net::DSCP_CS0) {
       // We receieved a non-transient error, and it seems we have
       // not changed the DSCP in the past, disable DSCP as it unlikely
       // to work in the future.
       last_dscp_ = net::DSCP_NO_CHANGE;
     }
   }
+
+  uint64 call_record = reinterpret_cast<uint64>(
+      new AsyncCallRecord(packet.id, base::TimeTicks::Now().ToInternalValue()));
+
   packet_processing_helpers::ApplyPacketOptions(
       packet.data->data(), packet.size, packet.packet_options, 0);
   int result = socket_->SendTo(
       packet.data.get(),
       packet.size,
       packet.to,
-      base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this), packet.id));
+      base::Bind(
+          &P2PSocketHostUdp::OnSend, base::Unretained(this), call_record));

[Alexei Svitkine (slow), 2014/11/07 22:24:35]

I think you should be able to bind to the params directly without needing
call_record, i.e.

 base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this), packet.id,
base::TimeTicks::Now().ToInternalValue()) should work, if OnSend is modified to
take those params.

 
   // sendto() may return an error, e.g. if we've received an ICMP Destination
   // Unreachable message. When this happens try sending the same packet again,
   // and just drop it if it fails again.
   if (IsTransientError(result)) {
     result = socket_->SendTo(
         packet.data.get(),
         packet.size,
         packet.to,
-        base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this),
-                   packet.id));
+        base::Bind(
+            &P2PSocketHostUdp::OnSend, base::Unretained(this), call_record));
   }
 
   if (result == net::ERR_IO_PENDING) {
     send_pending_ = true;
   } else {
-    HandleSendResult(packet.id, result);
+    HandleSendResult(call_record, result);
   }
 
   if (dump_outgoing_rtp_packet_)
     DumpRtpPacket(packet.data->data(), packet.size, false);
 }
 
-void P2PSocketHostUdp::OnSend(uint64 packet_id, int result) {
+void P2PSocketHostUdp::OnSend(uint64 call_record, int result) {
   DCHECK(send_pending_);
+
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
-  HandleSendResult(packet_id, result);
+  HandleSendResult(call_record, result);
 
   // Send next packets if we have them waiting in the buffer.
   while (state_ == STATE_OPEN && !send_queue_.empty() && !send_pending_) {
     PendingPacket packet = send_queue_.front();
     DoSend(packet);
     send_queue_.pop_front();
     DecrementDelayedBytes(packet.size);
   }
 }
 
-void P2PSocketHostUdp::HandleSendResult(uint64 packet_id, int result) {
+void P2PSocketHostUdp::HandleSendResult(uint64 call_record, int result) {
+  scoped_ptr<AsyncCallRecord> call_record_ptr(
+      reinterpret_cast<AsyncCallRecord*>(call_record));
+  uint64 packet_id = call_record_ptr->packet_id;
+  uint64 ticks_received = call_record_ptr->ticks_received;
+
   TRACE_EVENT_ASYNC_END1("p2p", "Send", packet_id,
                          "result", result);
   if (result < 0) {
     if (!IsTransientError(result)) {
       LOG(ERROR) << "Error when sending data in UDP socket: " << result;
       OnError();
       return;
     }
     VLOG(0) << "sendto() has failed twice returning a "
                " transient error. Dropping the packet.";
   }
+
+  // UMA to track the histograms from 1ms to 1 sec for how long a packet spends
+  // in the browser process.
+  UMA_HISTOGRAM_TIMES(
+      "WebRTC.SystemSendPacketDuration_UDP" /* name */,
+      base::TimeTicks::Now() -
+          base::TimeTicks::FromInternalValue(ticks_received) /* sample */);
+
   message_sender_->Send(new P2PMsg_OnSendComplete(id_));
 }
 
 P2PSocketHost* P2PSocketHostUdp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 bool P2PSocketHostUdp::SetOption(P2PSocketOption option, int value) {
   DCHECK_EQ(STATE_OPEN, state_);
   switch (option) {
     case P2P_SOCKET_OPT_RCVBUF:
       return socket_->SetReceiveBufferSize(value) == net::OK;
     case P2P_SOCKET_OPT_SNDBUF:
       return socket_->SetSendBufferSize(value) == net::OK;
     case P2P_SOCKET_OPT_DSCP:
       return (net::OK == socket_->SetDiffServCodePoint(
           static_cast<net::DiffServCodePoint>(value))) ? true : false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace content