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/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"
 
 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 = 4;
 
 // 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(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 338 matching lines @@
   if (!stream_.VerifyBytes(&decoded_data[kPacketNumberLength],
                            message_length - kPacketNumberLength)) {
     return PATTERN_CHANGED;
   }
 
   packets_received_mask_ |= 1 << (packet_index - 1);
   return SUCCESS;
 }
 
 // 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";
   const char* kUdpString = "UDP";
   const char* protocol_string;
   if (protocol == PROTOCOL_TCP)
     protocol_string = kTcpString;
   else
     protocol_string = kUdpString;
 
+  int32 port = kPorts[histogram_port];
+
   // Build <load_size> string.
   const char* kSmallLoadString = "100B";
   const char* kLargeLoadString = "1K";
   const char* load_size_string;
   if (load_size == kSmallTestBytesToSend)
     load_size_string = kSmallLoadString;
   else
     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>" 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,
+      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>.Status.<port>.<load_size>" histogram
-  // name. Total number of histograms are 2*5*2.
-  *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.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,
                                     const Status& status,
                                     int result) {
   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) {
     base::Histogram* packet_loss_histogram = base::LinearHistogram::FactoryGet(
         packet_loss_histogram_name,
         1,
         2 << kMaximumPackets,
         (2 << kMaximumPackets) + 1,
         base::Histogram::kUmaTargetedHistogramFlag);
     packet_loss_histogram->Add(packets_received_mask_);
     return;
   }
 
   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);
+
+    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.
 UDPStatsClient::UDPStatsClient()
     : NetworkStats() {
 }
 
 UDPStatsClient::~UDPStatsClient() {
 }
 
@@ skipping 102 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;
 }
 
+// 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) {
   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);
-
-  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