NetConnectivity - Collect stats for TCP/UDP network

chrome/browser/net/network_stats.cc

Index: chrome/browser/net/network_stats.cc
===================================================================
--- chrome/browser/net/network_stats.cc	(revision 135105)
+++ chrome/browser/net/network_stats.cc	(working copy)
@@ -16,11 +16,13 @@
 #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/sys_addrinfo.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"
@@ -94,6 +96,7 @@
     : 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),
@@ -108,13 +111,18 @@
 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(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(
@@ -130,6 +138,7 @@
 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.
@@ -140,6 +149,7 @@
   packets_to_send_ = packets_to_send;
 
   histogram_port_ = histogram_port;
+  has_proxy_server_ = has_proxy_server;
   finished_callback_ = finished_callback;
 }
 
@@ -498,15 +508,20 @@
 }
 
 // static
-void NetworkStats::GetHistogramNames(const ProtocolValue& protocol,
-                                     HistogramPortSelector port,
-                                     uint32 load_size,
-                                     int result,
-                                     std::string* rtt_histogram_name,
-                                     std::string* status_histogram_name,
-                                     std::string* packet_loss_histogram_name) {
-  CHECK_GE(port, PORT_53);
-  CHECK_LE(port, HISTOGRAM_PORT_MAX);
+void NetworkStats::GetHistogramNames(
+    const ProtocolValue& protocol,
+    HistogramPortSelector histogram_port,
+    bool has_proxy_server,
+    uint32 load_size,
+    int result,
+    std::string* rtt_histogram_name,
+    std::string* rtt_no_proxy_histogram_name,
+    std::string* status_histogram_name,
+    std::string* status_no_proxy_histogram_name,
+    std::string* packet_loss_histogram_name,
+    std::string* packet_loss_no_proxy_histogram_name) {

[jar (doing other things), 2012/05/03 16:41:34]

If you put ".NoProxy" at the end of the name, construction of these other names
would be much less complex (you might not need to even calculate them here).

[ramant (doing other things), 2012/05/04 03:53:11]

Done.

+  CHECK_GE(histogram_port, PORT_53);
+  CHECK_LE(histogram_port, HISTOGRAM_PORT_MAX);
 
   // Build <protocol> string.
   const char* kTcpString = "TCP";
@@ -517,6 +532,8 @@
   else
     protocol_string = kUdpString;
 
+  int32 port = kPorts[histogram_port];
+
   // Build <load_size> string.
   const char* kSmallLoadString = "100B";
   const char* kLargeLoadString = "1K";
@@ -527,31 +544,62 @@
     load_size_string = kLargeLoadString;
 
   // Build "NetConnectivity.<protocol>.Success.<port>.<load_size>.RTT"
-  // histogram name. Total number of histograms are 2*5*2.
-  if (result == net::OK) {
+  // and "NetConnectivity.<protocol>.NoProxy.Success.<port>.<load_size>.RTT"
+  // histogram names. Total number of histograms are 2*5*2*2.
+  if (result != net::OK) {
+    rtt_histogram_name->clear();
+  } else {
     *rtt_histogram_name = base::StringPrintf(
         "NetConnectivity.%s.Success.%d.%s.RTT",
         protocol_string,
-        kPorts[port],
+        port,
         load_size_string);
+    if (has_proxy_server) {
+      rtt_no_proxy_histogram_name->clear();
+    } else {
+      *rtt_no_proxy_histogram_name = base::StringPrintf(
+          "NetConnectivity.%s.NoProxy.Success.%d.%s.RTT",
+          protocol_string,
+          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(
+  // Build "NetConnectivity.<protocol>.Status.<port>.<load_size>" and
+  // "NetConnectivity.<protocol>.NoProxy.Status.<port>.<load_size>" histogram
+  // name. Total number of histograms are 2*2*5*2.
+  *status_histogram_name = base::StringPrintf(
       "NetConnectivity.%s.Status.%d.%s",
       protocol_string,
-      kPorts[port],
+      port,
       load_size_string);
+  if (has_proxy_server) {
+    status_no_proxy_histogram_name->clear();
+  } else {
+    *status_no_proxy_histogram_name = base::StringPrintf(
+        "NetConnectivity.%s.NoProxy.Status.%d.%s",
+        protocol_string,
+        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.PacketLoss.%d.%s",
       protocol_string,
-      kPorts[port],
+      port,
       load_size_string);
+  if (has_proxy_server) {
+    packet_loss_no_proxy_histogram_name->clear();
+  } else {
+    *packet_loss_no_proxy_histogram_name = base::StringPrintf(
+        "NetConnectivity.%s.NoProxy.PacketLoss.%d.%s",
+        protocol_string,
+        port,
+        load_size_string);
+  }
 }
 
 void NetworkStats::RecordHistograms(const ProtocolValue& protocol,
@@ -560,15 +608,22 @@
   base::TimeDelta duration = base::TimeTicks::Now() - start_time();
 
   std::string rtt_histogram_name;
+  std::string rtt_no_proxy_histogram_name;
   std::string status_histogram_name;
+  std::string status_no_proxy_histogram_name;
   std::string packet_loss_histogram_name;
+  std::string packet_loss_no_proxy_histogram_name;
   GetHistogramNames(protocol,
                     histogram_port_,
+                    has_proxy_server_,
                     load_size_,
                     result,
                     &rtt_histogram_name,
+                    &rtt_no_proxy_histogram_name,
                     &status_histogram_name,
-                    &packet_loss_histogram_name);
+                    &status_no_proxy_histogram_name,
+                    &packet_loss_histogram_name,
+                    &packet_loss_no_proxy_histogram_name);
 
   // For packet loss test, just record packet loss data.
   if (packets_to_send_ > 1) {
@@ -589,12 +644,28 @@
         base::TimeDelta::FromSeconds(60), 50,
         base::Histogram::kUmaTargetedHistogramFlag);
     rtt_histogram->AddTime(duration);
+
+    if (!has_proxy_server_) {
+      base::Histogram* rtt_no_proxy_histogram = base::Histogram::FactoryTimeGet(
+          rtt_no_proxy_histogram_name,
+          base::TimeDelta::FromMilliseconds(10),
+          base::TimeDelta::FromSeconds(60), 50,
+          base::Histogram::kUmaTargetedHistogramFlag);
+      rtt_no_proxy_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);
+  if (!has_proxy_server_) {
+    base::Histogram* status_no_proxy_histogram =
+        base::LinearHistogram::FactoryGet(
+            status_no_proxy_histogram_name, 1, STATUS_MAX, STATUS_MAX+1,
+            base::Histogram::kUmaTargetedHistogramFlag);
+    status_no_proxy_histogram->Add(status);
+  }
 }
 
 // UDPStatsClient methods and members.
@@ -717,6 +788,98 @@
   delete this;
 }
 
+// ProxyClient methods and members.
+ProxyClient::ProxyClient(const std::string& network_stats_server,
+                         NetworkStats::HistogramPortSelector histogram_port,
+                         IOThread* io_thread)
+    : network_stats_server_(network_stats_server),
+      histogram_port_(histogram_port),
+      io_thread_(io_thread) {
+}
+
+ProxyClient::~ProxyClient() {
+}
+
+void ProxyClient::ResolveProxy() {
+  std::string url = base::StringPrintf("https://%s:%d",
+                                       network_stats_server_.c_str(),
+                                       kPorts[histogram_port_]);
+  GURL gurl(url);
+  net::ProxyService* service =
+      io_thread_->globals()->system_proxy_service.get();
+
+  int rv = service->ResolveProxy(
+      gurl,
+      &proxy_info_,
+      base::Bind(&ProxyClient::OnResolveProxyComplete,
+                 base::Unretained(this)),
+      NULL,
+      net::BoundNetLog());
+  if (rv == net::OK)
+    OnResolveProxyComplete(rv);
+}
+
+void ProxyClient::OnResolveProxyComplete(int result) {
+  bool has_proxy_server = (proxy_info_.proxy_server().is_valid() &&
+                           !proxy_info_.proxy_server().is_direct());
+
+  net::HostResolver* host_resolver = io_thread_->globals()->host_resolver.get();
+  DCHECK(host_resolver);
+
+  DCHECK_GE(histogram_port_, NetworkStats::PORT_53);
+  DCHECK_LE(histogram_port_, NetworkStats::PORT_8080);
+  net::HostPortPair server_address(network_stats_server_,
+                                   kPorts[histogram_port_]);
+
+  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_, 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_, 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_, 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_, 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_, has_proxy_server,
+            kLargeTestBytesToSend, kMaximumPackets, net::CompletionCallback());
+      }
+      break;
+  }
+}
+
 // static
 void CollectNetworkStats(const std::string& network_stats_server,
                          IOThread* io_thread) {
@@ -742,8 +905,6 @@
 
   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()) {
@@ -782,7 +943,6 @@
           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];
     }
   }
 
@@ -797,58 +957,9 @@
 
   ++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);
-
-  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,
-            kSmallTestBytesToSend, 1, net::CompletionCallback());
-      }
-      break;
-
-    case 2:
-      {
-        UDPStatsClient* large_udp_stats = new UDPStatsClient();
-        large_udp_stats->Start(
-            host_resolver, server_address, histogram_port,
-            kLargeTestBytesToSend, 1, net::CompletionCallback());
-      }
-      break;
-
-    case 3:
-      {
-        TCPStatsClient* small_tcp_client = new TCPStatsClient();
-        small_tcp_client->Start(
-            host_resolver, server_address, histogram_port,
-            kSmallTestBytesToSend, 1, net::CompletionCallback());
-      }
-      break;
-
-    case 4:
-      {
-        TCPStatsClient* large_tcp_client = new TCPStatsClient();
-        large_tcp_client->Start(
-            host_resolver, server_address, histogram_port,
-            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,
-            kLargeTestBytesToSend, kMaximumPackets, net::CompletionCallback());
-      }
-      break;
-  }
+  ProxyClient* proxy_client = new ProxyClient(
+      network_stats_server, histogram_port, io_thread);
+  proxy_client->ResolveProxy();
 }
 
 }  // namespace chrome_browser_net