Collect stats to investigate the viability of UDP

chrome/browser/net/network_stats.h

+// Copyright (c) 2011 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/scoped_ptr.h"
+#include "base/time.h"
+#include "net/base/completion_callback.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/io_buffer.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/test_data_stream.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?
+// c) What is the latency for UDP and TCP.
+// d) If connectivity failed, at what stage (Connect or Write or Read) did it
+// fail?
+
+class NetworkStats {
+ public:
+  enum Status {              // Used in HISTOGRAM_ENUMERATION.
+    SUCCESS,                 // Successfully received bytes from the server.
+    IP_STRING_PARSE_FAILED,  // Parsing of IP string failed.
+    RESOLVE_FAILED,          // Host resolution failed.
+    CONNECT_FAILED,          // Connection to the server failed.
+    WRITE_FAILED,            // Sending an echo message to the server failed.
+    READ_FAILED,             // Reading the reply from the server failed.
+    READ_VERIFY_FAILED,      // Verification of data failed.
+    STATUS_MAX,              // Bounding value.
+  };
+
+  // Constructs an NetworkStats object that collects metrics for network
+  // connectivity (either TCP or UDP).
+  NetworkStats();
+  virtual ~NetworkStats();
+
+  // Returns the number of errors this server encountered.
+  int error_count() { return errors_; }
+
+ protected:
+  static const int kMaxMessage = 1024;
+
+  // Verifies the data and calls Finish() if there is an error or if all bytes
+  // are read. Returns true if Finish() is called otherwise returns false.
+  virtual bool ReadComplete(int result);
+
+  // Callbacks when an internal IO is completed.
+  virtual void OnReadComplete(int result);
+  virtual void OnWriteComplete(int result);
+
+  // Reads data from server until an error occurs.
+  virtual void ReadData();
+
+  // Sends data to server until an error occurs.
+  virtual int SendData();
+
+  // Collects network connectivity stats. This is called when all the data from
+  // server is read or when there is a failure during connect/read/write.
+  virtual void Finish(Status status, int result) {}

[willchan no longer on Chromium, 2011/06/04 19:26:51]

I think this is the only method that needs to be virtual. Why are the other ones
virtual? Also, why is this protected? Do subclasses need to call it? If not,
make it private. I'd also encourage subclasses not to call the parent
implementation, as that leads to implementation inheritance and the
http://en.wikipedia.org/wiki/Fragile_base_class problem.

[ramant (doing other things), 2011/06/05 17:54:13]

unittests provide finish_callback_. If we couldn't parse the ip address or host
resolver fails then sub classes Finish() method which calls finish_callback_.

Added helper methods so that sub classes don't access private data.

Done.

+
+  // The socket handle for this session.

[willchan no longer on Chromium, 2011/06/04 19:26:51]

All these member variables should be private:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Access....

[ramant (doing other things), 2011/06/05 17:54:13]

Done.

+  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.
+  int errors_;
+  int load_size_;
+  int bytes_to_read_;
+  int bytes_to_send_;
+
+  // |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_;
+
+  // Callback to call when data is read from the server.
+  net::CompletionCallbackImpl<NetworkStats> read_callback_;
+
+  // Callback to call when data is sent to the server.
+  net::CompletionCallbackImpl<NetworkStats> write_callback_;
+
+  // 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_;
+};
+
+class UDPStatsClient : public base::RefCounted<UDPStatsClient>, NetworkStats {
+ public:
+  // Constructs an UDPStatsClient object that collects metrics for UDP
+  // connectivity.
+  UDPStatsClient();
+  virtual ~UDPStatsClient();
+
+  // 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(const std::string& ip_str,
+             int port,
+             int bytes_to_send,
+             net::CompletionCallback* callback);
+
+ protected:
+  // Allow tests to access our innards for testing purposes.
+  friend class NetworkStatsTestUDP;
+
+  friend class base::RefCounted<UDPStatsClient>;
+
+  // 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.
+  virtual void Finish(Status status, int result);
+};
+
+class TCPStatsClient : public base::RefCounted<TCPStatsClient>, NetworkStats {
+ public:
+  // Constructs a TCPStatsClient object that collects metrics for TCP
+  // connectivity.
+  TCPStatsClient();
+  virtual ~TCPStatsClient();
+
+  // Starts the client, connecting to |server|.
+  // Client will send |bytes_to_send| bytes.
+  // When the 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(const net::HostPortPair& server,
+             int bytes_to_send,
+             net::CompletionCallback* callback);
+
+ protected:
+  // Allow tests to access our innards for testing purposes.
+  friend class NetworkStatsTestTCP;
+
+  friend class base::RefCounted<TCPStatsClient>;
+
+  // Callback that is called when connect is completed.
+  void OnConnectComplete(int result);
+
+  // 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.
+  virtual void Finish(Status status, int result);
+
+  // Callback to call when connect is completed.
+  net::CompletionCallbackImpl<TCPStatsClient> connect_callback_;
+};
+
+// 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".
+void CollectNetworkStats(const std::string& network_stats_server_url);
+
+}  // namespace chrome_browser_net
+
+#endif  // CHROME_BROWSER_NET_NETWORK_STATS_H_