NetConnectivity - Collect stats for TCP/UDP network

chrome/browser/net/network_stats.h

 // 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.
 
 #ifndef CHROME_BROWSER_NET_NETWORK_STATS_H_
 #define CHROME_BROWSER_NET_NETWORK_STATS_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/browser/io_thread.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/test_data_stream.h"
+#include "net/proxy/proxy_info.h"
 #include "net/socket/socket.h"
 namespace chrome_browser_net {
 
 // This class is used for live experiment of network connectivity (either TCP or
 // UDP) metrics. A small percentage of users participate in this experiment. All
 // users (who are in the experiment) must have enabled "UMA upload".
 //
 // This class collects the following stats from users who have opted in.
 // a) What percentage of users can get a message end-to-end to a UDP server?
 // b) What percentage of users can get a message end-to-end to a TCP server?
@@ skipping 60 matching lines @@
   // Starts the client, connecting to |server|.
   // Client will send |bytes_to_send| bytes to |server|.
   // When client has received all echoed bytes from the server, or
   // when an error occurs causing the client to stop, |Finish| will be
   // called with a net status code.
   // |Finish| will collect histogram stats.
   // Returns true if successful in starting the client.
   bool Start(net::HostResolver* host_resolver,
              const net::HostPortPair& server,
              HistogramPortSelector histogram_port,
+             bool has_proxy_server,
              uint32 bytes_to_send,
              uint32 packets_to_send,
              const net::CompletionCallback& callback);
 
  protected:
   // Constructs an NetworkStats object that collects metrics for network
   // connectivity (either TCP or UDP).
   NetworkStats();
+  // NetworkStats is deleted when Finish() is called.
   virtual ~NetworkStats();
 
   // Initializes |finished_callback_| and the number of bytes to send to the
   // server. |finished_callback| is called when we are done with the test.
   // |finished_callback| is mainly useful for unittests.
   void Initialize(uint32 bytes_to_send,
                   HistogramPortSelector histogram_port,
+                  bool has_proxy_server,
                   uint32 packets_to_send,
                   const net::CompletionCallback& finished_callback);
 
   // Called after host is resolved. UDPStatsClient and TCPStatsClient implement
   // this method. They create the socket and connect to the server.
   virtual bool DoConnect(int result) = 0;
 
   // This method is called after socket connection is completed. It will start
   // the process of sending packets to |server| by calling SendPacket(). Returns
   // false if connection is not established (result is less than 0).
@@ skipping 90 matching lines @@
 
   // This method parses the "echo response" message in the |response| to verify
   // that the <payload> is same as what we had sent in "echo request" message.
   // As it verifies the response in each packet, it also extracts the packet
   // number, and records that said packet number responded. It returns SUCCESS,
   // if all the bytes are verified.
   NetworkStats::Status VerifyBytes(const std::string& response);
 
   // Returns the histogram names for collecting network connectivity stats.
   // This is called by RecordHistograms. It sets the histogram names in
-  // |rtt_histogram_name| and |status_histogram_name|.
-  // If |result| equals to net::OK, it returns
+  // |rtt_histogram_name|, |status_histogram_name| and
+  // |packet_loss_histogram_name| and the corresponding no_proxy versions if
+  // there is no proxy server. It returns
+  // "NetConnectivity.<protocol>.Status.<port>.<load_size>" as histogram name
+  // for status histogram in |status_histogram_name| and
+  // "NetConnectivity.<protocol>.PacketLoss.<port>.<load_size>" as histogram
+  // name for packet loss histogram. If |result| equals to net::OK, it returns
   // "NetConnectivity.<protocol>.Success.<port>.<load_size>.RTT" as histogram
-  // name for RTT histogram,
-  // "NetConnectivity.<protocol>.Status.<port>.<load_size>" as histogram name
-  // for status histogram and
-  // "NetConnectivity.<protocol>.PacketLoss.<port>.<load_size>" as histogram
-  // name for packet loss histogram.
+  // name in |rtt_histogram_name|. If |has_proxy_server| is false, it returns
+  // "NetConnectivity.<protocol>.NoProxy.Success.<port>.<load_size>.RTT" as
+  // no proxy RTT histogram,
+  // "NetConnectivity.<protocol>.NoProxy.Status.<port>.<load_size>" as no proxy

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

I expect that you'll be most interesting in comparing otherwise identical stats,
with and without the proxy.  As a result, it would be "nice" if they
alphabetized next to each other.  To make that happen, I'd suggest putting
"NoProxy" at the absolute end of the new name.
NetConnectivity.<protocol>.Status.<port>.load_size>.NoProxy

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

Done.

+  // status histogram and
+  // "NetConnectivity.<protocol>.NoProxy.PacketLoss.<port>.<load_size>" as no
+  // proxy packet loss histogram.
   // |protocol| argument sets <protocol> in the histogram name. It would be
   // either TCP or UDP. <port> is the string representation of |histogram_port|.
   // |load_size| argument determines <load_size> in the histogram name. It would
   // be either 100B or 1K.
-  static void GetHistogramNames(const ProtocolValue& protocol,
-                                HistogramPortSelector histogram_port,
-                                uint32 load_size,
-                                int result,
-                                std::string* rtt_histogram_name,
-                                std::string* status_histogram_name,
-                                std::string* packet_loss_histogram_name);
+  static void 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);
 
   // The socket handle for this session.
   scoped_ptr<net::Socket> socket_;
 
   // The read buffer used to read data from the socket.
   scoped_refptr<net::IOBuffer> read_buffer_;
 
   // The write buffer used to write data to the socket.
   scoped_refptr<net::DrainableIOBuffer> write_buffer_;
 
   // Some counters for the session.
   uint32 load_size_;
   uint32 bytes_to_read_;
   uint32 bytes_to_send_;
 
   // The encoded message read from the server.
   std::string encoded_message_;
 
   // |stream_| is used to generate data to be sent to the server and it is also
   // used to verify the data received from the server.
   net::TestDataStream stream_;
 
   // |histogram_port_| specifies the port for which we are testing the network
   // connectivity.
   HistogramPortSelector histogram_port_;
 
+  // |has_proxy_server_| specifies if there is a proxy server or not.
+  bool has_proxy_server_;
+
   // HostResolver fills out the |addresses_| after host resolution is completed.
   net::AddressList addresses_;
 
   // Callback to call when echo protocol is successefully finished or whenever
   // there is an error (this allows unittests to wait until echo protocol's
   // round trip is finished).
   net::CompletionCallback finished_callback_;
 
   // The time when the session was started.
   base::TimeTicks start_time_;
 
   // Data to track number of packets to send to the server and the packets we
   // have received from the server.
   uint32 packets_to_send_;
   uint32 packets_sent_;
   uint32 base_packet_number_;
   uint32 packets_received_mask_;
 
   // We use this factory to create timeout tasks for socket's ReadData.
   base::WeakPtrFactory<NetworkStats> weak_factory_;
 };
 
 class UDPStatsClient : public NetworkStats {
  public:
   // Constructs an UDPStatsClient object that collects metrics for UDP
   // connectivity.
   UDPStatsClient();
+  // UDPStatsClient is deleted when Finish() is called.
   virtual ~UDPStatsClient();
 
  protected:
   // Allow tests to access our innards for testing purposes.
   friend class NetworkStatsTestUDP;
 
   // Called after host is resolved. Creates UDClientSocket and connects to the
   // server. If successfully connected, then calls ConnectComplete() to start
   // the echo protocol. Returns |false| if there is any error.
   virtual bool DoConnect(int result) OVERRIDE;
 
   // This method calls NetworkStats::ReadComplete() to verify the data and calls
   // Finish() if there is an error or if read callback didn't return any data
   // (|result| is less than or equal to 0).
   virtual bool ReadComplete(int result) OVERRIDE;
 
   // Collects stats for UDP connectivity. This is called when all the data from
-  // server is read or when there is a failure during connect/read/write.
+  // server is read or when there is a failure during connect/read/write. This
+  // object is deleted at the end of this method.
   virtual void Finish(Status status, int result) OVERRIDE;
 };
 
 class TCPStatsClient : public NetworkStats {
  public:
   // Constructs a TCPStatsClient object that collects metrics for TCP
   // connectivity.
   TCPStatsClient();
+  // TCPStatsClient is deleted when Finish() is called.
   virtual ~TCPStatsClient();
 
  protected:
   // Allow tests to access our innards for testing purposes.
   friend class NetworkStatsTestTCP;
 
   // Called after host is resolved. Creates TCPClientSocket and connects to the
   // server.
   virtual bool DoConnect(int result) OVERRIDE;
 
   // This method calls NetworkStats::ReadComplete() to verify the data and calls
   // Finish() if there is an error (|result| is less than 0).
   virtual bool ReadComplete(int result) OVERRIDE;
 
   // Collects stats for TCP connectivity. This is called when all the data from
-  // server is read or when there is a failure during connect/read/write.
+  // server is read or when there is a failure during connect/read/write. This
+  // object is deleted at the end of this method.
   virtual void Finish(Status status, int result) OVERRIDE;
 
  private:
   // Callback that is called when connect is completed and calls
   // ConnectComplete() to start the echo protocol.
   void OnConnectComplete(int result);
 };
 
+class ProxyClient {

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

I'm surprised to see this much work.  Is the intent to run the tests "through"
the proxy?

I was expecting to see proxy detection, and then a see the histograms that are
currently emitted split into with/without a proxy (tangentially) present
(without changing the "test").

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

No. This code to detect the proxy runs before we run the test.

Renamed ProxyClient to ProxyDetector. Should we rename to a different name?
thanks.

+ public:
+  // Constructs a ProxyClient object that resolves if access to
+  // network_stats_server goes through a proxy server or not.
+  ProxyClient(const std::string& network_stats_server,
+              NetworkStats::HistogramPortSelector histogram_port,
+              IOThread* io_thread);
+  virtual ~ProxyClient();
+
+  // This method uses system ProxyService to resolve the proxy for the given
+  // |network_stats_server| and |histogram_port|.
+  void ResolveProxy();
+
+  // Collects the network connectivity stats for UDP and TCP protocols.
+  void OnResolveProxyComplete(int result);
+
+ private:
+  // |network_stats_server_| specifies the TCP/UDP echo server name.
+  std::string network_stats_server_;
+
+  // |histogram_port_| specifies the port for which we are testing the network
+  // connectivity.
+  NetworkStats::HistogramPortSelector histogram_port_;
+
+  // |proxy_info_| holds proxy information returned by ResolveProxy.
+  net::ProxyInfo proxy_info_;
+
+  // The IOThread for accessing global HostResolver to resolve
+  // network_stats_server_ host and for accessing global system ProxyService.
+  // |io_thread_| is accessed on IO thread and it is safe to access it on IO
+  // thread.
+  IOThread* io_thread_;
+};
+
 // This collects the network connectivity stats for UDP and TCP for small
 // percentage of users who are participating in the experiment. All users must
 // have enabled "UMA upload". This method gets called only if UMA upload to the
 // server has succeeded.
 void CollectNetworkStats(const std::string& network_stats_server_url,
                          IOThread* io_thread);
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_NETWORK_STATS_H_