NetConnectivity - Collect stats for TCP/UDP network

chrome/browser/net/network_stats_unittest.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 "base/basictypes.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/net/network_stats.h"
 #include "net/base/host_resolver.h"
 #include "net/base/mock_host_resolver.h"
@@ skipping 18 matching lines @@
 
 class NetworkStatsTestUDP : public NetworkStatsTest {
  public:
   NetworkStatsTestUDP()
       : test_server_(net::TestServer::TYPE_UDP_ECHO,
                      net::TestServer::kLocalhost,
                      FilePath(FILE_PATH_LITERAL("net/data"))) {
   }
 
  protected:
-  void RunUDPEchoTest(int bytes, int packets) {
+  void RunUDPEchoTest(int bytes, int packets, bool has_proxy) {
     net::TestCompletionCallback cb;
 
     scoped_ptr<net::MockHostResolver> host_resolver(
         new net::MockHostResolver());
 
     // We will use HISTOGRAM_PORT_MAX as the PortIndex enum for testing
     // purposes.
     UDPStatsClient* udp_stats_client = new UDPStatsClient();
     EXPECT_TRUE(udp_stats_client->Start(host_resolver.get(),
                                         test_server_.host_port_pair(),
                                         NetworkStats::HISTOGRAM_PORT_MAX,
+                                        has_proxy,
                                         bytes,
                                         packets,
                                         cb.callback()));
     int rv = cb.WaitForResult();
     // Check there were no errors during connect/write/read to echo UDP server.
     EXPECT_EQ(0, rv);
   }
 
   net::TestServer test_server_;
 };
 
 class NetworkStatsTestTCP : public NetworkStatsTest {
  public:
   NetworkStatsTestTCP()
       : test_server_(net::TestServer::TYPE_TCP_ECHO,
                      net::TestServer::kLocalhost,
                      FilePath(FILE_PATH_LITERAL("net/data"))) {
   }
 
  protected:
-  void RunTCPEchoTest(int bytes, int packets) {
+  void RunTCPEchoTest(int bytes, int packets, bool has_proxy) {
     net::TestCompletionCallback cb;
 
     scoped_ptr<net::MockHostResolver> host_resolver(
         new net::MockHostResolver());
 
     // We will use HISTOGRAM_PORT_MAX as the PortIndex enum for testing
     // purposes.
     TCPStatsClient* tcp_stats_client = new TCPStatsClient();
     EXPECT_TRUE(tcp_stats_client->Start(host_resolver.get(),
                                         test_server_.host_port_pair(),
                                         NetworkStats::HISTOGRAM_PORT_MAX,
+                                        has_proxy,
                                         bytes,
                                         packets,
                                         cb.callback()));
     int rv = cb.WaitForResult();
     // Check there were no errors during connect/write/read to echo TCP server.
     EXPECT_EQ(0, rv);
   }
 
   net::TestServer test_server_;
 };
 
-TEST_F(NetworkStatsTestUDP, UDPEcho_100B_Of_Data) {
+TEST_F(NetworkStatsTestUDP, UDPEcho100BytesHasProxy) {
   ASSERT_TRUE(test_server_.Start());
-  RunUDPEchoTest(100, 1);
+  RunUDPEchoTest(100, 1, true);
 }
 
-TEST_F(NetworkStatsTestUDP, UDPEcho_1K_Of_Data) {
+TEST_F(NetworkStatsTestUDP, UDPEcho100BytesNoProxy) {
   ASSERT_TRUE(test_server_.Start());
-  RunUDPEchoTest(1024, 1);
+  RunUDPEchoTest(100, 1, false);
 }
 
-TEST_F(NetworkStatsTestUDP, UDPEchoMultiplePackets) {
+TEST_F(NetworkStatsTestUDP, UDPEcho1KBytesHasProxy) {
   ASSERT_TRUE(test_server_.Start());
-  RunUDPEchoTest(1024, 4);
+  RunUDPEchoTest(1024, 1, true);
 }
 
-TEST_F(NetworkStatsTestTCP, TCPEcho_100B_Of_Data) {
+TEST_F(NetworkStatsTestUDP, UDPEcho1KBytesNoProxy) {
   ASSERT_TRUE(test_server_.Start());
-  RunTCPEchoTest(100, 1);
+  RunUDPEchoTest(1024, 1, false);
 }
 
-TEST_F(NetworkStatsTestTCP, TCPEcho_1K_Of_Data) {
+TEST_F(NetworkStatsTestUDP, UDPEchoMultiplePacketsHasProxy) {
   ASSERT_TRUE(test_server_.Start());
-  RunTCPEchoTest(1024, 1);
+  RunUDPEchoTest(1024, 4, true);
+}
+
+TEST_F(NetworkStatsTestUDP, UDPEchoMultiplePacketsNoProxy) {
+  ASSERT_TRUE(test_server_.Start());
+  RunUDPEchoTest(1024, 4, false);
+}
+
+TEST_F(NetworkStatsTestTCP, TCPEcho100BytesHasProxy) {
+  ASSERT_TRUE(test_server_.Start());
+  RunTCPEchoTest(100, 1, true);
+}
+
+TEST_F(NetworkStatsTestTCP, TCPEcho100BytesNoProxy) {
+  ASSERT_TRUE(test_server_.Start());
+  RunTCPEchoTest(100, 1, false);
+}
+
+TEST_F(NetworkStatsTestTCP, TCPEcho1KBytesHasProxy) {
+  ASSERT_TRUE(test_server_.Start());
+  RunTCPEchoTest(1024, 1, true);
+}
+
+TEST_F(NetworkStatsTestTCP, TCPEcho1KBytesNoProxy) {
+  ASSERT_TRUE(test_server_.Start());
+  RunTCPEchoTest(1024, 1, false);
 }
 
 TEST_F(NetworkStatsTestTCP, VerifyBytes) {
   static const uint32 KBytesToSend = 100;
   static const uint32 packets_to_send = 1;
   static const uint32 packet_number = 1;
   TCPStatsClient network_stats;
   net::TestCompletionCallback cb;
   network_stats.Initialize(KBytesToSend,
                            NetworkStats::HISTOGRAM_PORT_MAX,
+                           true,
                            packets_to_send,
                            cb.callback());
 
   std::string message;
   EXPECT_EQ(NetworkStats::ZERO_LENGTH_ERROR,
             network_stats.VerifyBytes(message));
 
   std::string version = base::StringPrintf("%02d", 1);
   std::string invalid_checksum = base::StringPrintf("%010d", 0);
   std::string payload_size = base::StringPrintf("%07d", KBytesToSend);
@@ skipping 102 matching lines @@
   message = version + checksum + payload_size + key_string + invalid_payload;
   EXPECT_EQ(NetworkStats::PATTERN_CHANGED, network_stats.VerifyBytes(message));
   EXPECT_EQ(0u, network_stats.packets_received_mask());
 
   message = version + checksum + payload_size + key_string + encoded_payload;
   EXPECT_EQ(NetworkStats::SUCCESS, network_stats.VerifyBytes(message));
   EXPECT_EQ(1u, network_stats.packets_received_mask());
 }
 
 TEST_F(NetworkStatsTest, GetHistogramNames) {
-  // Test TCP, large packet, success histogram name.
   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;
+
+  // Test TCP, large packet, success histogram name, without proxy server.
   NetworkStats::GetHistogramNames(NetworkStats::PROTOCOL_TCP,
                                   NetworkStats::PORT_53,
+                                  false,  // Has no proxy.
                                   1024,
                                   net::OK,
                                   &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);
   EXPECT_EQ("NetConnectivity.TCP.Success.53.1K.RTT", rtt_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.NoProxy.Success.53.1K.RTT",
+            rtt_no_proxy_histogram_name);
   EXPECT_EQ("NetConnectivity.TCP.Status.53.1K", status_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.NoProxy.Status.53.1K",
+            status_no_proxy_histogram_name);
   EXPECT_EQ("NetConnectivity.TCP.PacketLoss.53.1K", packet_loss_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.NoProxy.PacketLoss.53.1K",
+            packet_loss_no_proxy_histogram_name);
 
-  // Test UDP, small packet, failure histogram name.
-  std::string rtt_histogram_name1;
-  std::string status_histogram_name1;
+  // Test TCP, large packet, success histogram name, with proxy server.
+  NetworkStats::GetHistogramNames(NetworkStats::PROTOCOL_TCP,
+                                  NetworkStats::PORT_53,
+                                  true,  // Has proxy.
+                                  1024,
+                                  net::OK,
+                                  &rtt_histogram_name,
+                                  &rtt_no_proxy_histogram_name,
+                                  &status_histogram_name,
+                                  &status_no_proxy_histogram_name,
+                                  &packet_loss_histogram_name,
+                                  &packet_loss_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.Success.53.1K.RTT", rtt_histogram_name);
+  EXPECT_EQ("", rtt_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.Status.53.1K", status_histogram_name);
+  EXPECT_EQ("", status_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.TCP.PacketLoss.53.1K", packet_loss_histogram_name);
+  EXPECT_EQ("", packet_loss_no_proxy_histogram_name);
+
+  // Test UDP, small packet, failure histogram name, without proxy server.
   std::string packet_loss_histogram_name1;
   NetworkStats::GetHistogramNames(NetworkStats::PROTOCOL_UDP,
                                   NetworkStats::PORT_6121,
+                                  false,  // Has no proxy.
                                   100,
                                   net::ERR_INVALID_ARGUMENT,
-                                  &rtt_histogram_name1,
-                                  &status_histogram_name1,
-                                  &packet_loss_histogram_name1);
-  EXPECT_EQ("", rtt_histogram_name1);
-  EXPECT_EQ("NetConnectivity.UDP.Status.6121.100B", status_histogram_name1);
+                                  &rtt_histogram_name,
+                                  &rtt_no_proxy_histogram_name,
+                                  &status_histogram_name,
+                                  &status_no_proxy_histogram_name,
+                                  &packet_loss_histogram_name,
+                                  &packet_loss_no_proxy_histogram_name);
+  EXPECT_EQ("", rtt_histogram_name);
+  EXPECT_EQ("", rtt_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.UDP.Status.6121.100B", status_histogram_name);
+  EXPECT_EQ("NetConnectivity.UDP.NoProxy.Status.6121.100B",
+            status_no_proxy_histogram_name);
   EXPECT_EQ("NetConnectivity.UDP.PacketLoss.6121.100B",
-            packet_loss_histogram_name1);
+            packet_loss_histogram_name);
+  EXPECT_EQ("NetConnectivity.UDP.NoProxy.PacketLoss.6121.100B",
+            packet_loss_no_proxy_histogram_name);
+
+  // Test UDP, small packet, failure histogram name, with proxy server.
+  NetworkStats::GetHistogramNames(NetworkStats::PROTOCOL_UDP,
+                                  NetworkStats::PORT_6121,
+                                  true,  // Has proxy.
+                                  100,
+                                  net::ERR_INVALID_ARGUMENT,
+                                  &rtt_histogram_name,
+                                  &rtt_no_proxy_histogram_name,
+                                  &status_histogram_name,
+                                  &status_no_proxy_histogram_name,
+                                  &packet_loss_histogram_name,
+                                  &packet_loss_no_proxy_histogram_name);
+  EXPECT_EQ("", rtt_histogram_name);
+  EXPECT_EQ("", rtt_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.UDP.Status.6121.100B", status_histogram_name);
+  EXPECT_EQ("", status_no_proxy_histogram_name);
+  EXPECT_EQ("NetConnectivity.UDP.PacketLoss.6121.100B",
+            packet_loss_histogram_name);
+  EXPECT_EQ("", packet_loss_no_proxy_histogram_name);
 }
 
 }  // namespace chrome_browser_net