Collect stats to investigate the viability of UDP

chrome/browser/net/network_stats.cc

+// 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.
+
+#include "chrome/browser/net/network_stats.h"
+
+#include "base/callback_old.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/task.h"
+#include "base/threading/platform_thread.h"
+#include "base/time.h"
+#include "base/tuple.h"
+#include "content/browser/browser_thread.h"
+#include "net/base/address_list.h"
+#include "net/base/host_resolver.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/socket/tcp_client_socket.h"
+#include "net/udp/udp_client_socket.h"
+#include "net/udp/udp_server_socket.h"
+
+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.
+static const int kSmallTestBytesToSend = 100;
+
+// This specifies the number of bytes to be sent to the TCP/UDP servers as part
+// of large packet size test.
+static const int kLargeTestBytesToSend = 1200;
+
+// NetworkStats methods and members.
+NetworkStats::NetworkStats()
+    : errors_(0),
+      bytes_to_read_(0),
+      bytes_to_send_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          read_callback_(this, &NetworkStats::OnReadComplete)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          write_callback_(this, &NetworkStats::OnWriteComplete)),
+      finished_callback_(NULL),
+      start_time_(base::TimeTicks::Now()) {
+}
+
+NetworkStats::~NetworkStats() {
+  read_buffer_ = NULL;
+}
+
+bool NetworkStats::ReadComplete(int result) {
+  DCHECK(socket_.get());
+  if (result < 0) {
+    errors_++;
+    Finish(READ_FAILED, result);
+    return true;
+  }
+
+  if (!stream_.VerifyBytes(read_buffer_->data(), result)) {
+    errors_++;
+    Finish(READ_VERIFY_FAILED, result);
+    return true;
+  }
+
+  read_buffer_ = NULL;
+  bytes_to_read_ -= result;
+
+  // No more data to read.
+  if (!bytes_to_read_) {
+    Finish(SUCCESS, net::OK);
+    return true;
+  }
+  ReadData();
+  return false;
+}
+
+void NetworkStats::OnReadComplete(int result) {
+  ReadComplete(result);
+}
+
+void NetworkStats::OnWriteComplete(int result) {
+  DCHECK(socket_.get());
+  if (result < 0) {
+    errors_++;
+    Finish(WRITE_FAILED, result);
+    return;
+  }
+
+  write_buffer_->DidConsume(result);
+  bytes_to_send_ -= result;
+  if (!write_buffer_->BytesRemaining())
+      write_buffer_ = NULL;
+
+  if (bytes_to_send_) {
+    int rv = SendData();
+    if (rv < 0) {
+      if (rv != net::ERR_IO_PENDING) {
+        errors_++;
+        Finish(WRITE_FAILED, rv);
+        return;
+      }
+    }
+  }
+}
+
+void NetworkStats::ReadData() {
+  DCHECK(!read_buffer_.get());
+  // We release the read_buffer_ in the destructor if there is an error.
+  read_buffer_ = new net::IOBuffer(kMaxMessage);
+
+  int rv;
+  do {
+    DCHECK(socket_.get());
+    rv = socket_->Read(read_buffer_, kMaxMessage, &read_callback_);
+    if (rv == net::ERR_IO_PENDING)
+      return;
+    if (ReadComplete(rv))  // Complete the read manually.
+      return;
+  } while (rv > 0);
+}
+
+int NetworkStats::SendData() {
+  DCHECK(bytes_to_send_);   // We should have data to send.
+  do {
+    if (!write_buffer_.get()) {
+      scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(bytes_to_send_));
+      stream_.GetBytes(buffer->data(), bytes_to_send_);
+      write_buffer_ = new net::DrainableIOBuffer(buffer, bytes_to_send_);
+    }
+
+    DCHECK(socket_.get());
+    int rv = socket_->Write(write_buffer_,
+                            write_buffer_->BytesRemaining(),
+                            &write_callback_);
+    if (rv < 0)
+      return rv;
+    write_buffer_->DidConsume(rv);
+    bytes_to_send_ -= rv;
+    if (!write_buffer_->BytesRemaining())
+      write_buffer_ = NULL;
+  } while (bytes_to_send_);
+  return net::OK;
+}
+
+// UDPStatsClient methods and members.
+UDPStatsClient::UDPStatsClient()
+    : NetworkStats() {
+}
+
+UDPStatsClient::~UDPStatsClient() {
+}
+
+bool UDPStatsClient::Start(const std::string& ip_str,
+                           int port,
+                           int bytes_to_send,
+                           net::CompletionCallback* callback) {
+  DCHECK(!socket_.get());
+  DCHECK(port);
+  DCHECK(bytes_to_send);   // We should have data to send.
+
+  AddRef();  // Released on Finish().
+
+  finished_callback_ = callback;
+  load_size_ = bytes_to_send;
+  bytes_to_send_ = bytes_to_send;
+  bytes_to_read_ = bytes_to_send;
+
+  net::IPAddressNumber ip_number;
+  if (!net::ParseIPLiteralToNumber(ip_str, &ip_number)) {
+    errors_++;
+    Finish(IP_STRING_PARSE_FAILED, net::ERR_INVALID_ARGUMENT);
+    return false;
+  }
+
+  net::IPEndPoint server_address = net::IPEndPoint(ip_number, port);
+
+  net::UDPClientSocket* socket =
+     new net::UDPClientSocket(NULL, net::NetLog::Source());
+  DCHECK(socket);
+  socket_.reset(socket);
+
+  int rv = socket->Connect(server_address);
+  if (rv < 0) {
+    errors_++;
+    Finish(CONNECT_FAILED, rv);
+    return false;
+  }
+
+  start_time_ = base::TimeTicks::Now();
+  rv = SendData();
+  if (rv < 0) {
+    if (rv != net::ERR_IO_PENDING) {
+      errors_++;
+      Finish(WRITE_FAILED, rv);
+      return false;
+    }
+  }
+
+  stream_.Reset();
+  ReadData();
+
+  return true;
+}
+
+void UDPStatsClient::Finish(Status status, int result) {
+  base::TimeDelta duration = base::TimeTicks::Now() - start_time_;
+  if (load_size_ == kSmallTestBytesToSend) {
+    if (result == net::OK)
+      UMA_HISTOGRAM_TIMES("NetConnectivity.UDP.Success.100B.RTT", duration);
+    else
+      UMA_HISTOGRAM_TIMES("NetConnectivity.UDP.Fail.100B.RTT", duration);
+
+    UMA_HISTOGRAM_ENUMERATION(
+        "NetConnectivity.UDP.Status.100B", status, STATUS_MAX);
+  } else {
+    if (result == net::OK)
+      UMA_HISTOGRAM_TIMES("NetConnectivity.UDP.Success.1K.RTT", duration);
+    else
+      UMA_HISTOGRAM_TIMES("NetConnectivity.UDP.Fail.1K.RTT", duration);
+
+    UMA_HISTOGRAM_ENUMERATION(
+        "NetConnectivity.UDP.Status.1K", status, STATUS_MAX);
+  }
+
+  if (finished_callback_ != NULL) {
+    net::CompletionCallback* callback = finished_callback_;
+    finished_callback_ = NULL;
+    callback->Run(result);
+  }
+
+  // Close the socket so that there are no more IO operations.
+  if (socket_.get()) {
+    net::UDPClientSocket* socket =
+        static_cast<net::UDPClientSocket*>(socket_.get());
+    socket->Close();
+    socket_.reset();
+  }
+
+  // We may be holding the last reference. Do not access |this| after Release().
+  Release();  // Acquired on Start().
+}
+
+// TCPStatsClient methods and members.
+TCPStatsClient::TCPStatsClient()
+  : NetworkStats(),
+    ALLOW_THIS_IN_INITIALIZER_LIST(
+        connect_callback_(this, &TCPStatsClient::OnConnectComplete)) {
+}
+
+TCPStatsClient::~TCPStatsClient() {
+}
+
+bool TCPStatsClient::Start(const net::HostPortPair& server_host_port_pair,
+                           int bytes_to_send,
+                           net::CompletionCallback* callback) {
+  DCHECK(!socket_.get());
+  DCHECK(bytes_to_send);   // We should have data to send.
+
+  AddRef();  // Released on Finish().
+
+  finished_callback_ = callback;
+  load_size_ = bytes_to_send;
+  bytes_to_send_ = bytes_to_send;
+  bytes_to_read_ = bytes_to_send;
+
+  scoped_ptr<net::HostResolver> system_host_resolver(
+      net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism,
+                                    net::HostResolver::kDefaultRetryAttempts,
+                                    NULL));
+  net::SingleRequestHostResolver host_resolver(system_host_resolver.get());
+  net::HostResolver::RequestInfo request(server_host_port_pair);
+  net::AddressList addresses;
+  int rv = host_resolver.Resolve(request, &addresses, NULL, net::BoundNetLog());
+  if (rv != net::OK) {
+    errors_++;
+    Finish(RESOLVE_FAILED, rv);
+    return false;
+  }
+
+  net::TCPClientSocket* socket =
+      new net::TCPClientSocket(addresses, NULL, net::NetLog::Source());
+  DCHECK(socket);
+  socket_.reset(socket);
+
+  rv = socket->Connect(&connect_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    return true;
+
+  OnConnectComplete(rv);
+  return rv == net::OK;
+}
+
+void TCPStatsClient::OnConnectComplete(int result) {
+  if (result < 0) {
+    errors_++;
+    Finish(CONNECT_FAILED, result);
+    return;
+  }
+
+  DCHECK(bytes_to_send_);   // We should have data to send.
+
+  start_time_ = base::TimeTicks::Now();
+
+  int rv = SendData();
+  if (rv < 0) {
+    if (rv != net::ERR_IO_PENDING) {
+      errors_++;
+      Finish(WRITE_FAILED, rv);
+      return;
+    }
+  }
+
+  stream_.Reset();
+  ReadData();
+}
+
+void TCPStatsClient::Finish(Status status, int result) {
+  base::TimeDelta duration = base::TimeTicks::Now() - start_time_;
+  if (load_size_ == kSmallTestBytesToSend) {
+    if (result == net::OK)
+      UMA_HISTOGRAM_TIMES("NetConnectivity.TCP.Success.100B.RTT", duration);
+    else
+      UMA_HISTOGRAM_TIMES("NetConnectivity.TCP.Fail.100B.RTT", duration);
+
+    UMA_HISTOGRAM_ENUMERATION(
+        "NetConnectivity.TCP.Status.100B", status, STATUS_MAX);
+  } else {
+    if (result == net::OK)
+      UMA_HISTOGRAM_TIMES("NetConnectivity.TCP.Success.1K.RTT", duration);
+    else
+      UMA_HISTOGRAM_TIMES("NetConnectivity.TCP.Fail.1K.RTT", duration);
+
+    UMA_HISTOGRAM_ENUMERATION(
+        "NetConnectivity.TCP.Status.1K", status, STATUS_MAX);
+  }
+
+  if (finished_callback_ != NULL) {
+    net::CompletionCallback* callback = finished_callback_;
+    finished_callback_ = NULL;
+    callback->Run(result);
+  }
+
+  // Disconnect the socket so that there are no more IO operations.
+  if (socket_.get()) {
+    net::TCPClientSocket* socket =
+        static_cast<net::TCPClientSocket*>(socket_.get());
+    socket->Disconnect();
+    socket_.reset();
+  }
+
+  // We may be holding the last reference. Do not access |this| after Release().
+  Release();  // Acquired on Start().
+}
+
+// static
+void CollectNetworkStats(const std::string& network_stats_server) {
+  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,
+        NewRunnableFunction(&CollectNetworkStats, network_stats_server));
+    return;
+  }
+
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Collect network stats is there is a network connection.
+  if (net::NetworkChangeNotifier::IsOffline())
+    return;
+
+  static scoped_refptr<base::FieldTrial> trial = NULL;
+  static bool collect_stats = false;
+
+  if (!trial.get()) {
+    // Set up a field trial to collect network stats for UDP and TCP.
+    base::FieldTrial::Probability kDivisor = 1000;
+
+    // Enable the connectivity testing for 0.5% of the users.
+    base::FieldTrial::Probability kProbabilityPerGroup = 5;
+
+    // After October 30, 2011 builds, it will always be in default group
+    // (disable_network_stats).
+    trial = new base::FieldTrial("NetworkConnectivity", kDivisor,
+                                 "disable_network_stats", 2011, 10, 30);
+
+    // Add option to collect_stats for NetworkConnectivity.
+    int collect_stats_group = trial->AppendGroup("collect_stats",
+                                                 kProbabilityPerGroup);
+    if (trial->group() == collect_stats_group)
+      collect_stats = true;
+  }
+
+  if (!collect_stats)
+    return;
+
+  // Run test once.
+  static 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;
+
+  scoped_refptr<UDPStatsClient> small_udp_stats(new UDPStatsClient());
+  small_udp_stats->Start(
+      network_stats_server, 6121, kSmallTestBytesToSend, NULL);
+
+  scoped_refptr<UDPStatsClient> large_udp_stats(new UDPStatsClient());
+  large_udp_stats->Start(
+      network_stats_server, 6121, kLargeTestBytesToSend, NULL);
+
+  net::HostPortPair server_address(network_stats_server, 80);
+  scoped_refptr<TCPStatsClient> small_tcp_client(new TCPStatsClient());
+  small_tcp_client->Start(server_address, kSmallTestBytesToSend, NULL);
+
+  scoped_refptr<TCPStatsClient> large_tcp_client(new TCPStatsClient());
+  large_tcp_client->Start(server_address, kLargeTestBytesToSend, NULL);
+}
+
+}  // namespace chrome_browser_net