NetConnectivity - Collect stats for TCP/UDP network

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
+#include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/test_completion_callback.h"
+#include "net/proxy/proxy_service.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
 // This specifies the number of bytes to be sent to the TCP/UDP servers as part
 // of small packet size test.
@@ skipping 53 matching lines @@
 
 // Maximum number of packets that can be sent to the server for packet loss
 // testing.
 static const uint32 kMaximumPackets = 6;
 
 // NetworkStats methods and members.
 NetworkStats::NetworkStats()
     : load_size_(0),
       bytes_to_read_(0),
       bytes_to_send_(0),
+      has_proxy_server_(false),
       packets_to_send_(0),
       packets_sent_(0),
       base_packet_number_(0),
       packets_received_mask_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 NetworkStats::~NetworkStats() {
   socket_.reset();
 }
 
 bool NetworkStats::Start(net::HostResolver* host_resolver,
                          const net::HostPortPair& server_host_port_pair,
                          HistogramPortSelector histogram_port,
+                         bool has_proxy_server,
                          uint32 bytes_to_send,
                          uint32 packets_to_send,
                          const net::CompletionCallback& finished_callback) {
+  DCHECK(host_resolver);
   DCHECK(bytes_to_send);   // We should have data to send.
   DCHECK_LE(packets_to_send, kMaximumPackets);
 
-  Initialize(bytes_to_send, histogram_port, packets_to_send, finished_callback);
+  Initialize(bytes_to_send,
+             histogram_port,
+             has_proxy_server,
+             packets_to_send,
+             finished_callback);
 
   net::HostResolver::RequestInfo request(server_host_port_pair);
   int rv = host_resolver->Resolve(
       request, &addresses_,
       base::Bind(&NetworkStats::OnResolveComplete,
                  base::Unretained(this)),
       NULL, net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     return true;
   return DoConnect(rv);
 }
 
 void NetworkStats::Initialize(
     uint32 bytes_to_send,
     HistogramPortSelector histogram_port,
+    bool has_proxy_server,
     uint32 packets_to_send,
     const net::CompletionCallback& finished_callback) {
   DCHECK(bytes_to_send);    // We should have data to send.
   DCHECK(packets_to_send);  // We should send at least 1 packet.
   DCHECK_LE(bytes_to_send, kLargeTestBytesToSend);
 
   load_size_ = bytes_to_send;
   packets_to_send_ = packets_to_send;
 
   histogram_port_ = histogram_port;
+  has_proxy_server_ = has_proxy_server;
   finished_callback_ = finished_callback;
 }
 
 uint32 SendingPacketSize(uint32 load_size) {
   return kVersionLength + kChecksumLength + kPayloadSizeLength + load_size;
 }
 
 uint32 ReceivingPacketSize(uint32 load_size) {
   return kVersionLength + kChecksumLength + kPayloadSizeLength + kKeyLength +
       load_size;
@@ skipping 378 matching lines @@
   if (result == net::OK) {
     *rtt_histogram_name = base::StringPrintf(
         "NetConnectivity.%s.Success.%d.%s.RTT",
         protocol_string,
         kPorts[port],
         load_size_string);
   }
 
   // Build "NetConnectivity.<protocol>.Status.<port>.<load_size>" histogram
   // name. Total number of histograms are 2*5*2.
-  *status_histogram_name =  base::StringPrintf(
+  *status_histogram_name = base::StringPrintf(
       "NetConnectivity.%s.Status.%d.%s",
       protocol_string,
       kPorts[port],
       load_size_string);
 
   // Build "NetConnectivity.<protocol>.PacketLoss.<port>.<load_size>" histogram
   // name. Total number of histograms are 5 (because we do this test for UDP
   // only).
-  *packet_loss_histogram_name =  base::StringPrintf(
+  *packet_loss_histogram_name = base::StringPrintf(
       "NetConnectivity.%s.PacketLoss6.%d.%s",
       protocol_string,
       kPorts[port],
       load_size_string);
 }
 
 void NetworkStats::RecordHistograms(const ProtocolValue& protocol,
                                     const Status& status,
                                     int result) {
   base::TimeDelta duration = base::TimeTicks::Now() - start_time();
 
   std::string rtt_histogram_name;
   std::string status_histogram_name;
   std::string packet_loss_histogram_name;
   GetHistogramNames(protocol,
                     histogram_port_,
                     load_size_,
                     result,
                     &rtt_histogram_name,
                     &status_histogram_name,
                     &packet_loss_histogram_name);
 
-  // For packet loss test, just record packet loss data.
-  if (packets_to_send_ > 1) {
-    base::Histogram* packet_loss_histogram = base::LinearHistogram::FactoryGet(
-        packet_loss_histogram_name,
-        1,
-        2 << kMaximumPackets,
-        (2 << kMaximumPackets) + 1,
+  size_t histogram_count = has_proxy_server_ ? 1 : 2;

[jar (doing other things), 2012/05/10 00:02:02]

nit: add comment:
// If we are running without a proxy, we'll generate 2 distinct histograms in
each case, one will have the ".NoProxy" suffix.

[ramant (doing other things), 2012/05/10 02:37:35]

Done.

+  for (size_t i = 0; i < histogram_count; i++) {
+    // For packet loss test, just record packet loss data.
+    if (packets_to_send_ > 1) {
+      base::Histogram* histogram = base::LinearHistogram::FactoryGet(
+          packet_loss_histogram_name,
+          1,
+          2 << kMaximumPackets,
+          (2 << kMaximumPackets) + 1,
+          base::Histogram::kUmaTargetedHistogramFlag);
+      histogram->Add(packets_received_mask_);
+      packet_loss_histogram_name.append(".NoProxy");
+      continue;

[jar (doing other things), 2012/05/10 00:02:02]

nit: Add comment: Packet loss histograms don't measure times or status.

[ramant (doing other things), 2012/05/10 02:37:35]

Done.

+    }
+
+    if (result == net::OK) {
+      base::Histogram* rtt_histogram = base::Histogram::FactoryTimeGet(
+          rtt_histogram_name,
+          base::TimeDelta::FromMilliseconds(10),
+          base::TimeDelta::FromSeconds(60), 50,
+          base::Histogram::kUmaTargetedHistogramFlag);
+      rtt_histogram->AddTime(duration);
+      rtt_histogram_name.append(".NoProxy");
+    }
+
+    base::Histogram* status_histogram = base::LinearHistogram::FactoryGet(
+        status_histogram_name, 1, STATUS_MAX, STATUS_MAX+1,
         base::Histogram::kUmaTargetedHistogramFlag);
-    packet_loss_histogram->Add(packets_received_mask_);
-    return;
+    status_histogram->Add(status);
+    status_histogram_name.append(".NoProxy");
   }
-
-  if (result == net::OK) {
-    base::Histogram* rtt_histogram = base::Histogram::FactoryTimeGet(
-        rtt_histogram_name,
-        base::TimeDelta::FromMilliseconds(10),
-        base::TimeDelta::FromSeconds(60), 50,
-        base::Histogram::kUmaTargetedHistogramFlag);
-    rtt_histogram->AddTime(duration);
-  }
-
-  base::Histogram* status_histogram = base::LinearHistogram::FactoryGet(
-      status_histogram_name, 1, STATUS_MAX, STATUS_MAX+1,
-      base::Histogram::kUmaTargetedHistogramFlag);
-  status_histogram->Add(status);
 }
 
 // UDPStatsClient methods and members.
 UDPStatsClient::UDPStatsClient()
     : NetworkStats() {
 }
 
 UDPStatsClient::~UDPStatsClient() {
 }
 
@@ skipping 100 matching lines @@
 
   // Disconnect the socket so that there are no more IO operations.
   net::TCPClientSocket* tcp_socket =
       static_cast<net::TCPClientSocket*>(socket());
   if (tcp_socket)
     tcp_socket->Disconnect();
 
   delete this;
 }
 
+// ProxyDetector methods and members.
+ProxyDetector::ProxyDetector(net::ProxyService* proxy_service,
+                             const net::HostPortPair& server_address,
+                             OnResolvedCallback callback)
+    : proxy_service_(proxy_service),
+      server_address_(server_address),
+      callback_(callback),
+      has_pending_proxy_resolution_(false) {
+}
+
+ProxyDetector::~ProxyDetector() {
+  CHECK(!has_pending_proxy_resolution_);
+}
+
+void ProxyDetector::StartResolveProxy() {
+  std::string url =
+      base::StringPrintf("https://%s", server_address_.ToString().c_str());
+  GURL gurl(url);
+
+  has_pending_proxy_resolution_ = true;
+  DCHECK(proxy_service_);
+  int rv = proxy_service_->ResolveProxy(
+      gurl,
+      &proxy_info_,
+      base::Bind(&ProxyDetector::OnResolveProxyComplete,
+                 base::Unretained(this)),
+      NULL,
+      net::BoundNetLog());
+  if (rv != net::ERR_IO_PENDING)
+    OnResolveProxyComplete(rv);
+}
+
+void ProxyDetector::OnResolveProxyComplete(int result) {
+  has_pending_proxy_resolution_ = false;
+  bool has_proxy_server = (result == net::OK &&
+                           proxy_info_.proxy_server().is_valid() &&
+                           !proxy_info_.proxy_server().is_direct());
+
+  callback_.Run(has_proxy_server);

[jar (doing other things), 2012/05/10 00:02:02]

As per your suggestion: Perchance this should be run via a post task.  It is
always hard to tell what state is held etc., and it is not perf critical (other
than the fact that you don't want to slow anything else down).

[ramant (doing other things), 2012/05/10 02:37:35]

Done.

+
+  // TODO(rtenneti): Will we leak if ProxtResolve is cancelled (or proxy

[jar (doing other things), 2012/05/10 00:02:02]

nit: typo: ProxtResolve --> ProxyResolve

[ramant (doing other things), 2012/05/10 02:37:35]

Done.

+  // resolution never completes).
+  delete this;
+}
+
 // static
 void CollectNetworkStats(const std::string& network_stats_server,
                          IOThread* io_thread) {
   if (network_stats_server.empty())
     return;
 
   // If we are not on IO Thread, then post a task to call CollectNetworkStats on
   // IO Thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             &CollectNetworkStats, network_stats_server, io_thread));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Check that there is a network connection. We get called only if UMA upload
   // to the server has succeeded.
   DCHECK(!net::NetworkChangeNotifier::IsOffline());
 
   CR_DEFINE_STATIC_LOCAL(scoped_refptr<base::FieldTrial>, trial, ());
   static bool collect_stats = false;
-
-  static uint32 port;
   static NetworkStats::HistogramPortSelector histogram_port;
 
   if (!trial.get()) {
     // Set up a field trial to collect network stats for UDP and TCP.
     const base::FieldTrial::Probability kDivisor = 1000;
 
     // Enable the connectivity testing for 0.5% of the users in stable channel.
     base::FieldTrial::Probability probability_per_group = 5;
 
     chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
@@ skipping 18 matching lines @@
     if (trial->group() == collect_stats_group)
       collect_stats = true;
 
     if (collect_stats) {
       // Pick a port randomly from the set of TCP/UDP echo server ports
       // specified in |kPorts|.
       histogram_port = static_cast<NetworkStats::HistogramPortSelector>(
           base::RandInt(NetworkStats::PORT_53, NetworkStats::PORT_8080));
       DCHECK_GE(histogram_port, NetworkStats::PORT_53);
       DCHECK_LE(histogram_port, NetworkStats::PORT_8080);
-      port = kPorts[histogram_port];
     }
   }
 
   if (!collect_stats)
     return;
 
   // Run test kMaxNumberOfTests times.
   const size_t kMaxNumberOfTests = INT_MAX;
   static size_t number_of_tests_done = 0;
   if (number_of_tests_done > kMaxNumberOfTests)
     return;
 
   ++number_of_tests_done;
 
   net::HostResolver* host_resolver = io_thread->globals()->host_resolver.get();
   DCHECK(host_resolver);
 
-  net::HostPortPair server_address(network_stats_server, port);
+  net::HostPortPair server_address(network_stats_server,
+                                   kPorts[histogram_port]);
 
+  net::ProxyService* proxy_service =
+      io_thread->globals()->system_proxy_service.get();
+  DCHECK(proxy_service);
+
+  ProxyDetector::OnResolvedCallback callback =
+      base::Bind(&StartNetworkStatsTest,
+          host_resolver, server_address, histogram_port);
+
+  ProxyDetector* proxy_client = new ProxyDetector(
+      proxy_service, server_address, callback);
+  proxy_client->StartResolveProxy();
+}
+
+// static
+void StartNetworkStatsTest(net::HostResolver* host_resolver,
+                           const net::HostPortPair& server_address,
+                           NetworkStats::HistogramPortSelector histogram_port,
+                           bool has_proxy_server) {
   int experiment_to_run = base::RandInt(1, 5);
   switch (experiment_to_run) {
     case 1:
       {
         UDPStatsClient* small_udp_stats = new UDPStatsClient();
         small_udp_stats->Start(
-            host_resolver, server_address, histogram_port,
+            host_resolver, server_address, histogram_port, has_proxy_server,
             kSmallTestBytesToSend, 1, net::CompletionCallback());
       }
       break;
 
     case 2:
       {
         UDPStatsClient* large_udp_stats = new UDPStatsClient();
         large_udp_stats->Start(
-            host_resolver, server_address, histogram_port,
+            host_resolver, server_address, histogram_port, has_proxy_server,
             kLargeTestBytesToSend, 1, net::CompletionCallback());
       }
       break;
 
     case 3:
       {
         TCPStatsClient* small_tcp_client = new TCPStatsClient();
         small_tcp_client->Start(
-            host_resolver, server_address, histogram_port,
+            host_resolver, server_address, histogram_port, has_proxy_server,
             kSmallTestBytesToSend, 1, net::CompletionCallback());
       }
       break;
 
     case 4:
       {
         TCPStatsClient* large_tcp_client = new TCPStatsClient();
         large_tcp_client->Start(
-            host_resolver, server_address, histogram_port,
+            host_resolver, server_address, histogram_port, has_proxy_server,
             kLargeTestBytesToSend, 1, net::CompletionCallback());
       }
       break;
 
     case 5:
       {
         UDPStatsClient* packet_loss_udp_stats = new UDPStatsClient();
         packet_loss_udp_stats->Start(
-            host_resolver, server_address, histogram_port,
+            host_resolver, server_address, histogram_port, has_proxy_server,
             kLargeTestBytesToSend, kMaximumPackets, net::CompletionCallback());
       }
       break;
   }
 }
 
 }  // namespace chrome_browser_net