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 "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 48 matching lines @@
 
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender,
                                    int socket_id,
                                    P2PMessageThrottler* throttler)
     : P2PSocketHost(message_sender, socket_id, P2PSocketHost::UDP),
       socket_(
           new net::UDPServerSocket(GetContentClient()->browser()->GetNetLog(),
                                    net::NetLog::Source())),
       send_pending_(false),
       last_dscp_(net::DSCP_CS0),
+      random_socket_id_prefix_(0),
       throttler_(throttler) {
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
+void P2PSocketHostUdp::SetSendBufferSize() {
+  int send_buffer_size = 0;
+  if (base::FieldTrialList::FindFullName("WebRTC-SystemUDPSendSocketSize") ==

[juberti2, 2014/11/04 06:00:18]

Seems like we should read FindFullName into a string and then compare that
string against the various values, instead of duping the FindFullName call each
time.

[Alexei Svitkine (slow), 2014/11/04 15:17:50]

Agreed.

[guoweis2, 2014/11/07 22:18:19]

Done.

+      "2K") {
+    send_buffer_size = 2048;
+  } else if (base::FieldTrialList::FindFullName(
+                 "WebRTC-SystemUDPSendSocketSize") == "64K") {

[Alexei Svitkine (slow), 2014/11/04 15:17:50]

I would normally suggest to use variation params here (go/finch-params), but
perhaps that API isn't exposed to the code in content/, in which I guess using
the experiment name is OK.

However, my suggestion would be to check StartsWith(name, "64K"). That way, you
can have multiple groups that specify the same behavior, which gives you more
flexibility in the config.

[guoweis2, 2014/11/07 22:18:19]

Variation is not allowed so following the pattern
https://code.google.com/p/chromium/codesearch#chromium/src/net/dns/host_cache...,
I'm parsing the group name and get the buffer size.

+    send_buffer_size = 65536;
+  } else if (base::FieldTrialList::FindFullName(
+                 "WebRTC-SystemUDPSendSocketSize") == "256K") {
+    send_buffer_size = 262144;

[Alexei Svitkine (slow), 2014/11/04 15:17:50]

Nit: It would be more readable to have these be 256 * 1024;

[guoweis2, 2014/11/07 22:18:19]

Done.

+  }
+
+  if (send_buffer_size > 0) {

[juberti2, 2014/11/04 06:00:18]

Probably want to invalidate the experiment if this happens, i.e. not record a
result

[guoweis2, 2014/11/07 22:18:19]

Alexei, is there a way to invalidate this instance of experiment? looking at
field_trial.h but can't find one.

+    // Setting send socket buffer size.
+    if (socket_->SetSendBufferSize(send_buffer_size) != net::OK) {
+      LOG(WARNING) << "Failed to set socket send buffer size to "
+                   << send_buffer_size;
+    }
+  }
+}
+
 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;
   }
 
+  SetSendBufferSize();
+
   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();
 
@@ skipping 73 matching lines @@
 void P2PSocketHostUdp::Send(const net::IPEndPoint& to,
                             const std::vector<char>& data,
                             const rtc::PacketOptions& options,
                             uint64 packet_id) {
   if (!socket_) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
+  // The lower 32 bits of packet id is a sequence number. 2^32 bits is a large
+  // number space. If we send 1000 packets per second, it'll take 49 days to
+  // finish 2^32 bits.
+  if (random_socket_id_prefix_ == 0) {
+    random_socket_id_prefix_ = (packet_id >> 32) << 32;
+  } else {
+    DCHECK_EQ((random_socket_id_prefix_ >> 32), (packet_id >> 32));
+  }
+
   if (!ContainsKey(connected_peers_, to)) {
     P2PSocketHost::StunMessageType type = P2PSocketHost::StunMessageType();
     bool stun = GetStunPacketType(&*data.begin(), data.size(), &type);
     if (!stun || type == STUN_DATA_INDICATION) {
       LOG(ERROR) << "Page tried to send a data packet to " << to.ToString()
                  << " before STUN binding is finished.";
       OnError();
       return;
     }
 
@@ skipping 31 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 =

[juberti2, 2014/11/04 06:00:18]

For the future, I think it would be better to allocate a structure rather than
peer into the internals of the packet id. (Yes, this was my suggestion, but I
didn't realize the assumptions the code would end up making.)

[guoweis2, 2014/11/07 22:18:19]

Changed to allocate memory.

+      PackCallRecord(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));
 
   // 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) {
+  uint64 packet_id;
+  uint64 ticks;
+  UnpackCallRecord(call_record,
+                   random_socket_id_prefix_,
+                   base::TimeTicks::Now().ToInternalValue(),
+                   &packet_id,
+                   &ticks);
+
   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_CUSTOM_TIMES(
+      "WebRTC.SystemSendPacketDuration_UDP" /* name */,
+      base::TimeDelta::FromInternalValue(ticks) /* sample */,
+      base::TimeDelta::FromMilliseconds(1) /* min */,
+      base::TimeDelta::FromSeconds(1) /* max */,
+      100 /* bucket_count */);

[Alexei Svitkine (slow), 2014/11/04 15:17:50]

I suggest just using UMA_HISTOGRAM_TIMES() here, with the only difference is
that version has a 10s max instead of 1s.

Since the histogram is exponential, you still get a lot of resolution in the
lower buckets, see for e.g.:

https://uma.googleplex.com/p/chrome/histograms/?dayCount=1&endDate=11-03-2014...

[guoweis2, 2014/11/07 22:18:19]

Done.

+
   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;
   }
 }
 
+#define ALL_ONES_LOWER_32_BITS ((1uLL << 32) - 1)
+
+uint64 P2PSocketHostUdp::PackCallRecord(const uint64 packet_id,
+                                        const uint64 ticks_now) {
+  // Lower 32 bits is the packet id.
+  uint64 call_record = packet_id & ALL_ONES_LOWER_32_BITS;
+  uint64 ticks_now_lower = ticks_now & ALL_ONES_LOWER_32_BITS;
+  return (ticks_now_lower << 32) + call_record;
+}
+
+void P2PSocketHostUdp::UnpackCallRecord(const uint64 packed_call_record,
+                                        const uint64 random_socket_id_prefix,
+                                        const uint64 ticks_now,
+                                        uint64* packet_id,
+                                        uint64* ticks_diff) {
+  // Prefix the random prefix to the packet id.
+  *packet_id =
+      (packed_call_record & ALL_ONES_LOWER_32_BITS) | random_socket_id_prefix;
+
+  // Calculate the tick spent.
+  int64 ticks_duration =
+      (ticks_now & ALL_ONES_LOWER_32_BITS) - (packed_call_record >> 32);
+
+  if (ticks_duration < 0) {
+    ticks_duration = ALL_ONES_LOWER_32_BITS + ticks_duration + 1;
+  }
+  *ticks_diff = ticks_duration;
+}
+
 }  // namespace content