chrome/browser/net/network_stats.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/net/network_stats.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/metrics/field_trial.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/rand_util.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/time/time.h"
  15 #include "chrome/common/chrome_version_info.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "net/base/load_flags.h"
  18 #include "net/base/net_errors.h"
  19 #include "net/base/network_change_notifier.h"
  20 #include "net/base/test_completion_callback.h"
  21 #include "net/dns/single_request_host_resolver.h"
  22 #include "net/proxy/proxy_service.h"
  23 #include "net/socket/client_socket_factory.h"
  24 #include "net/udp/datagram_client_socket.h"
  25 #include "url/gurl.h"
  26
  27 using content::BrowserThread;
  28
  29 namespace chrome_browser_net {
  30
  31 // static
  32 uint32 NetworkStats::maximum_tests_ = 8;
  33 // static
  34 uint32 NetworkStats::maximum_sequential_packets_ = 21;
  35 // static
  36 uint32 NetworkStats::maximum_NAT_packets_ = 2;
  37 // static
  38 uint32 NetworkStats::maximum_NAT_idle_seconds_ = 300;
  39 // static
  40 bool NetworkStats::start_test_after_connect_ = true;
  41
  42 // Specify the possible choices of probe packet sizes.
  43 const uint32 kProbePacketBytes[] = {100, 500, 1200};
  44 const uint32 kPacketSizeChoices = arraysize(kProbePacketBytes);
  45
  46 // List of ports used for probing test.
  47 const uint16 kPorts[] = {443, 80};
  48
  49 // Number of first few packets that are recorded in a packet-correlation
  50 // histogram, which shows exactly what sequence of packets were received.
  51 // We use this to deduce specific packet loss correlation.
  52 const uint32 kCorrelatedLossPacketCount = 6;
  53
  54 // This specifies the maximum message (payload) size of one packet.
  55 const uint32 kMaxMessageSize = 1600;
  56
  57 // This specifies the maximum udp receiver buffer size.
  58 const uint32 kMaxUdpReceiveBufferSize = 63000;
  59
  60 // This specifies the maximum udp receiver buffer size.
  61 const uint32 kMaxUdpSendBufferSize = 4096;
  62
  63 // This should match TestType except for the last one.
  64 const char* kTestName[] = {"TokenRequest", "StartPacket", "NonPacedPacket",
  65                            "PacedPacket", "NATBind", "PacketSizeTest"};
  66
  67 // Perform Pacing/Non-pacing test only if at least 2 packets are received
  68 // in the StartPacketTest.
  69 const uint32 kMinimumReceivedPacketsForPacingTest = 2;
  70 // Perform NAT binding test only if at least 10 packets are received.
  71 const uint32 kMinimumReceivedPacketsForNATTest = 10;
  72
  73 // Maximum inter-packet pacing interval in microseconds.
  74 const uint32 kMaximumPacingMicros = 1000000;
  75 // Timeout value for getting the token.
  76 const uint32 kGetTokenTimeoutSeconds = 10;
  77 // Timeout value for StartPacket and NonPacedPacket if the client does not get
  78 // reply. For PacedPacket test, the timeout value is this number plus the total
  79 // pacing interval.
  80 const uint32 kReadDataTimeoutSeconds = 30;
  81 // This is the timeout for NAT without Idle periods.
  82 // For NAT test with idle periods, the timeout is the Idle period + this value.
  83 const uint32 kReadNATTimeoutSeconds = 10;
  84 // This is the timeout for PACKET_SIZE_TEST.
  85 const uint32 kReadPacketSizeTimeoutSeconds = 10;
  86 // This is the maxmium number of packets we would send for PACKET_SIZE_TEST.
  87 uint32 kMaximumPacketSizeTestPackets = 1;
  88
  89 // These helper functions are similar to UMA_HISTOGRAM_XXX except that they do
  90 // not create a static histogram_pointer.
  91 void DynamicHistogramEnumeration(const std::string& name,
  92                                  uint32 sample,
  93                                  uint32 boundary_value) {
  94   base::HistogramBase* histogram_pointer = base::LinearHistogram::FactoryGet(
  95       name,
  96       1,
  97       boundary_value,
  98       boundary_value + 1,
  99       base::HistogramBase::kUmaTargetedHistogramFlag);
 100   histogram_pointer->Add(sample);
 101 }
 102
 103 void DynamicHistogramTimes(const std::string& name,
 104                            const base::TimeDelta& sample) {
 105   base::HistogramBase* histogram_pointer = base::Histogram::FactoryTimeGet(
 106       name,
 107       base::TimeDelta::FromMilliseconds(1),
 108       base::TimeDelta::FromSeconds(30),
 109       50,
 110       base::HistogramBase::kUmaTargetedHistogramFlag);
 111   histogram_pointer->AddTime(sample);
 112 }
 113
 114 void DynamicHistogramCounts(const std::string& name,
 115                             uint32 sample,
 116                             uint32 min,
 117                             uint32 max,
 118                             uint32 bucket_count) {
 119   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
 120       name, min, max, bucket_count,
 121       base::HistogramBase::kUmaTargetedHistogramFlag);
 122   histogram_pointer->Add(sample);
 123 }
 124
 125 NetworkStats::NetworkStats(net::ClientSocketFactory* socket_factory)
 126     : socket_factory_(socket_factory),
 127       histogram_port_(0),
 128       has_proxy_server_(false),
 129       probe_packet_bytes_(0),
 130       bytes_for_packet_size_test_(0),
 131       current_test_index_(0),
 132       read_state_(READ_STATE_IDLE),
 133       write_state_(WRITE_STATE_IDLE),
 134       weak_factory_(this) {
 135   ResetData();
 136 }
 137
 138 NetworkStats::~NetworkStats() {}
 139
 140 bool NetworkStats::Start(net::HostResolver* host_resolver,
 141                          const net::HostPortPair& server_host_port_pair,
 142                          uint16 histogram_port,
 143                          bool has_proxy_server,
 144                          uint32 probe_bytes,
 145                          uint32 bytes_for_packet_size_test,
 146                          const net::CompletionCallback& finished_callback) {
 147   DCHECK(host_resolver);
 148   histogram_port_ = histogram_port;
 149   has_proxy_server_ = has_proxy_server;
 150   probe_packet_bytes_ = probe_bytes;
 151   bytes_for_packet_size_test_ = bytes_for_packet_size_test;
 152   finished_callback_ = finished_callback;
 153   test_sequence_.clear();
 154   test_sequence_.push_back(TOKEN_REQUEST);
 155
 156   ResetData();
 157
 158   scoped_ptr<net::SingleRequestHostResolver> resolver(
 159       new net::SingleRequestHostResolver(host_resolver));
 160   net::HostResolver::RequestInfo request(server_host_port_pair);
 161   int rv =
 162       resolver->Resolve(request,
 163                         net::DEFAULT_PRIORITY,
 164                         &addresses_,
 165                         base::Bind(base::IgnoreResult(&NetworkStats::DoConnect),
 166                                    base::Unretained(this)),
 167                         net::BoundNetLog());
 168   if (rv == net::ERR_IO_PENDING) {
 169     resolver_.swap(resolver);
 170     return true;
 171   }
 172   return DoConnect(rv);
 173 }
 174
 175 void NetworkStats::StartOneTest() {
 176   if (test_sequence_[current_test_index_] == TOKEN_REQUEST) {
 177     DCHECK_EQ(WRITE_STATE_IDLE, write_state_);
 178     write_buffer_ = NULL;
 179     SendHelloRequest();
 180   } else {
 181     SendProbeRequest();
 182   }
 183 }
 184
 185 void NetworkStats::ResetData() {
 186   DCHECK_EQ(WRITE_STATE_IDLE, write_state_);
 187   write_buffer_ = NULL;
 188   packets_received_mask_.reset();
 189   first_arrival_time_ = base::TimeTicks();
 190   last_arrival_time_ = base::TimeTicks();
 191
 192   packet_rtt_.clear();
 193   packet_rtt_.resize(maximum_sequential_packets_);
 194   probe_request_time_ = base::TimeTicks();
 195   // Note: inter_arrival_time_ should not be reset here because it is used in
 196   // subsequent tests.
 197 }
 198
 199 bool NetworkStats::DoConnect(int result) {
 200   if (result != net::OK) {
 201     TestPhaseComplete(RESOLVE_FAILED, result);
 202     return false;
 203   }
 204
 205   scoped_ptr<net::DatagramClientSocket> udp_socket =
 206       socket_factory_->CreateDatagramClientSocket(
 207           net::DatagramSocket::DEFAULT_BIND,
 208           net::RandIntCallback(),
 209           NULL,
 210           net::NetLog::Source());
 211   DCHECK(udp_socket);
 212   DCHECK(!socket_);
 213   socket_ = udp_socket.Pass();
 214
 215   const net::IPEndPoint& endpoint = addresses_.front();
 216   int rv = socket_->Connect(endpoint);
 217   if (rv < 0) {
 218     TestPhaseComplete(CONNECT_FAILED, rv);
 219     return false;
 220   }
 221
 222   socket_->SetSendBufferSize(kMaxUdpSendBufferSize);
 223   socket_->SetReceiveBufferSize(kMaxUdpReceiveBufferSize);
 224   return ConnectComplete(rv);
 225 }
 226
 227 bool NetworkStats::ConnectComplete(int result) {
 228   if (result < 0) {
 229     TestPhaseComplete(CONNECT_FAILED, result);
 230     return false;
 231   }
 232
 233   if (start_test_after_connect_) {
 234     // Reads data for all HelloReply and all subsequent probe tests.
 235     if (ReadData() != net::ERR_IO_PENDING) {
 236       TestPhaseComplete(READ_FAILED, result);
 237       return false;
 238     }
 239     SendHelloRequest();
 240   } else {
 241     // For unittesting. Only run the callback, do not destroy it.
 242     if (!finished_callback_.is_null())
 243       finished_callback_.Run(result);
 244   }
 245   return true;
 246 }
 247
 248 void NetworkStats::SendHelloRequest() {
 249   StartReadDataTimer(kGetTokenTimeoutSeconds, current_test_index_);
 250   ProbePacket probe_packet;
 251   probe_message_.SetPacketHeader(ProbePacket_Type_HELLO_REQUEST, &probe_packet);
 252   probe_packet.set_group_id(current_test_index_);
 253   std::string output = probe_message_.MakeEncodedPacket(probe_packet);
 254
 255   int result = SendData(output);
 256   if (result < 0 && result != net::ERR_IO_PENDING)
 257     TestPhaseComplete(WRITE_FAILED, result);
 258 }
 259
 260 void NetworkStats::SendProbeRequest() {
 261   ResetData();
 262   // Use default timeout except for the NAT bind test.
 263   uint32 timeout_seconds = kReadDataTimeoutSeconds;
 264   uint32 number_packets = maximum_sequential_packets_;
 265   uint32 probe_bytes = probe_packet_bytes_;
 266   pacing_interval_ = base::TimeDelta();
 267   switch (test_sequence_[current_test_index_]) {
 268     case START_PACKET_TEST:
 269     case NON_PACED_PACKET_TEST:
 270       break;
 271     case PACED_PACKET_TEST: {
 272       pacing_interval_ =
 273           std::min(inter_arrival_time_,
 274                    base::TimeDelta::FromMicroseconds(kMaximumPacingMicros));
 275       timeout_seconds += pacing_interval_.InMicroseconds() *
 276                          (maximum_sequential_packets_ - 1) / 1000000;
 277       break;
 278     }
 279     case NAT_BIND_TEST: {
 280       // Make sure no integer overflow.
 281       DCHECK_LE(maximum_NAT_idle_seconds_, 4000U);
 282       int nat_test_idle_seconds = base::RandInt(1, maximum_NAT_idle_seconds_);
 283       pacing_interval_ = base::TimeDelta::FromSeconds(nat_test_idle_seconds);
 284       timeout_seconds = nat_test_idle_seconds + kReadNATTimeoutSeconds;
 285       number_packets = maximum_NAT_packets_;
 286       break;
 287     }
 288     case PACKET_SIZE_TEST: {
 289       number_packets = kMaximumPacketSizeTestPackets;
 290       probe_bytes = bytes_for_packet_size_test_;
 291       timeout_seconds = kReadPacketSizeTimeoutSeconds;
 292       break;
 293     }
 294     default:
 295       NOTREACHED();
 296       return;
 297   }
 298   DVLOG(1) << "NetworkStat: Probe pacing " << pacing_interval_.InMicroseconds()
 299            << " microseconds. Time out " << timeout_seconds << " seconds";
 300   ProbePacket probe_packet;
 301   probe_message_.GenerateProbeRequest(token_,
 302                                       current_test_index_,
 303                                       probe_bytes,
 304                                       pacing_interval_.InMicroseconds(),
 305                                       number_packets,
 306                                       &probe_packet);
 307   std::string output = probe_message_.MakeEncodedPacket(probe_packet);
 308
 309   StartReadDataTimer(timeout_seconds, current_test_index_);
 310   probe_request_time_ = base::TimeTicks::Now();
 311   int result = SendData(output);
 312   if (result < 0 && result != net::ERR_IO_PENDING)
 313     TestPhaseComplete(WRITE_FAILED, result);
 314 }
 315
 316 int NetworkStats::ReadData() {
 317   if (!socket_.get())
 318     return 0;
 319
 320   if (read_state_ == READ_STATE_READ_PENDING)
 321     return net::ERR_IO_PENDING;
 322
 323   int rv = 0;
 324   while (true) {
 325     DCHECK(!read_buffer_.get());
 326     read_buffer_ = new net::IOBuffer(kMaxMessageSize);
 327
 328     rv = socket_->Read(
 329         read_buffer_.get(),
 330         kMaxMessageSize,
 331         base::Bind(&NetworkStats::OnReadComplete, weak_factory_.GetWeakPtr()));
 332     if (rv <= 0)
 333       break;
 334     if (ReadComplete(rv))
 335       return rv;
 336   }
 337   if (rv == net::ERR_IO_PENDING)
 338     read_state_ = READ_STATE_READ_PENDING;
 339   return rv;
 340 }
 341
 342 void NetworkStats::OnReadComplete(int result) {
 343   DCHECK_NE(net::ERR_IO_PENDING, result);
 344   DCHECK_EQ(READ_STATE_READ_PENDING, read_state_);
 345
 346   read_state_ = READ_STATE_IDLE;
 347   if (!ReadComplete(result)) {
 348     // Called ReadData() via PostDelayedTask() to avoid recursion. Added a delay
 349     // of 1ms so that the time-out will fire before we have time to really hog
 350     // the CPU too extensively (waiting for the time-out) in case of an infinite
 351     // loop.
 352     base::MessageLoop::current()->PostDelayedTask(
 353         FROM_HERE,
 354         base::Bind(base::IgnoreResult(&NetworkStats::ReadData),
 355                    weak_factory_.GetWeakPtr()),
 356         base::TimeDelta::FromMilliseconds(1));
 357   }
 358 }
 359
 360 bool NetworkStats::ReadComplete(int result) {
 361   DCHECK(socket_.get());
 362   DCHECK_NE(net::ERR_IO_PENDING, result);
 363   if (result < 0) {
 364     // Something is wrong, finish the test.
 365     read_buffer_ = NULL;
 366     TestPhaseComplete(READ_FAILED, result);
 367     return true;
 368   }
 369
 370   std::string encoded_message(read_buffer_->data(),
 371                               read_buffer_->data() + result);
 372   read_buffer_ = NULL;
 373   ProbePacket probe_packet;
 374   if (!probe_message_.ParseInput(encoded_message, &probe_packet))
 375     return false;
 376   // Discard if the packet is for a different test.
 377   if (probe_packet.group_id() != current_test_index_)
 378     return false;
 379
 380   // Whether all packets in the current test have been received.
 381   bool current_test_complete = false;
 382   switch (probe_packet.header().type()) {
 383     case ProbePacket_Type_HELLO_REPLY:
 384       token_ = probe_packet.token();
 385       if (current_test_index_ == 0)
 386         test_sequence_.push_back(START_PACKET_TEST);
 387       current_test_complete = true;
 388       break;
 389     case ProbePacket_Type_PROBE_REPLY:
 390       current_test_complete = UpdateReception(probe_packet);
 391       break;
 392     default:
 393       DVLOG(1) << "Received unexpected packet type: "
 394                << probe_packet.header().type();
 395   }
 396
 397   if (!current_test_complete) {
 398     // All packets have not been received for the current test.
 399     return false;
 400   }
 401   // All packets are received for the current test.
 402   // Read completes if all tests are done (if TestPhaseComplete didn't start
 403   // another test).
 404   return TestPhaseComplete(SUCCESS, net::OK);
 405 }
 406
 407 bool NetworkStats::UpdateReception(const ProbePacket& probe_packet) {
 408   uint32 packet_index = probe_packet.packet_index();
 409   if (packet_index >= packet_rtt_.size())
 410     return false;
 411   packets_received_mask_.set(packet_index);
 412   TestType test_type = test_sequence_[current_test_index_];
 413   uint32 received_packets = packets_received_mask_.count();
 414
 415   // Now() has resolution ~1-15ms. HighResNow() has high resolution but it
 416   // is warned not to use it unless necessary.
 417   base::TimeTicks current_time = base::TimeTicks::Now();
 418   last_arrival_time_ = current_time;
 419   if (first_arrival_time_.is_null())
 420     first_arrival_time_ = current_time;
 421
 422   // Need to do this after updating the last_arrival_time_ since NAT_BIND_TEST
 423   // and PACKET_SIZE_TEST record the SendToLastRecvDelay.
 424   if (test_type == NAT_BIND_TEST) {
 425     return received_packets >= maximum_NAT_packets_;
 426   }
 427   if (test_type == PACKET_SIZE_TEST) {
 428     return received_packets >= kMaximumPacketSizeTestPackets;
 429   }
 430
 431   base::TimeDelta rtt =
 432       current_time - probe_request_time_ -
 433       base::TimeDelta::FromMicroseconds(std::max(
 434           static_cast<int64>(0), probe_packet.server_processing_micros()));
 435   base::TimeDelta min_rtt = base::TimeDelta::FromMicroseconds(1L);
 436   packet_rtt_[packet_index] = (rtt >= min_rtt) ? rtt : min_rtt;
 437
 438   if (received_packets < maximum_sequential_packets_)
 439     return false;
 440   // All packets in the current test are received.
 441   inter_arrival_time_ = (last_arrival_time_ - first_arrival_time_) /
 442       std::max(1U, (received_packets - 1));
 443   if (test_type == START_PACKET_TEST) {
 444     test_sequence_.push_back(PACKET_SIZE_TEST);
 445     test_sequence_.push_back(TOKEN_REQUEST);
 446     // No need to add TOKEN_REQUEST here when all packets are received.
 447     test_sequence_.push_back(base::RandInt(0, 1) ? PACED_PACKET_TEST
 448                                                  : NON_PACED_PACKET_TEST);
 449     test_sequence_.push_back(TOKEN_REQUEST);
 450     test_sequence_.push_back(NAT_BIND_TEST);
 451     test_sequence_.push_back(TOKEN_REQUEST);
 452   }
 453   return true;
 454 }
 455
 456 int NetworkStats::SendData(const std::string& output) {
 457   if (write_buffer_.get() || !socket_.get() ||
 458       write_state_ == WRITE_STATE_WRITE_PENDING) {
 459     return net::ERR_UNEXPECTED;
 460   }
 461   scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(output));
 462   write_buffer_ = new net::DrainableIOBuffer(buffer.get(), buffer->size());
 463
 464   int bytes_written = socket_->Write(
 465       write_buffer_.get(),
 466       write_buffer_->BytesRemaining(),
 467       base::Bind(&NetworkStats::OnWriteComplete, weak_factory_.GetWeakPtr()));
 468   if (bytes_written < 0) {
 469     if (bytes_written == net::ERR_IO_PENDING)
 470       write_state_ = WRITE_STATE_WRITE_PENDING;
 471     return bytes_written;
 472   }
 473   UpdateSendBuffer(bytes_written);
 474   return net::OK;
 475 }
 476
 477 void NetworkStats::OnWriteComplete(int result) {
 478   DCHECK_NE(net::ERR_IO_PENDING, result);
 479   DCHECK_EQ(WRITE_STATE_WRITE_PENDING, write_state_);
 480   write_state_ = WRITE_STATE_IDLE;
 481   if (result < 0 || !socket_.get() || write_buffer_.get() == NULL) {
 482     TestPhaseComplete(WRITE_FAILED, result);
 483     return;
 484   }
 485   UpdateSendBuffer(result);
 486 }
 487
 488 void NetworkStats::UpdateSendBuffer(int bytes_sent) {
 489   write_buffer_->DidConsume(bytes_sent);
 490   DCHECK_EQ(write_buffer_->BytesRemaining(), 0);
 491   DCHECK_EQ(WRITE_STATE_IDLE, write_state_);
 492   write_buffer_ = NULL;
 493 }
 494
 495 void NetworkStats::StartReadDataTimer(uint32 seconds, uint32 test_index) {
 496   base::MessageLoop::current()->PostDelayedTask(
 497       FROM_HERE,
 498       base::Bind(&NetworkStats::OnReadDataTimeout,
 499                  weak_factory_.GetWeakPtr(),
 500                  test_index),
 501       base::TimeDelta::FromSeconds(seconds));
 502 }
 503
 504 void NetworkStats::OnReadDataTimeout(uint32 test_index) {
 505   // If the current_test_index_ has changed since we set the timeout,
 506   // the current test has been completed, so do nothing.
 507   if (test_index != current_test_index_)
 508     return;
 509   // If test_type is TOKEN_REQUEST, it will do nothing but call
 510   // TestPhaseComplete().
 511   TestType test_type = test_sequence_[current_test_index_];
 512
 513   uint32 received_packets = packets_received_mask_.count();
 514   if (received_packets >= 2) {
 515     inter_arrival_time_ =
 516         (last_arrival_time_ - first_arrival_time_) / (received_packets - 1);
 517   }
 518   // Add other tests if this is START_PACKET_TEST.
 519   if (test_type == START_PACKET_TEST) {
 520     if (received_packets >= kMinimumReceivedPacketsForPacingTest) {
 521       test_sequence_.push_back(TOKEN_REQUEST);
 522       test_sequence_.push_back(PACKET_SIZE_TEST);
 523       test_sequence_.push_back(TOKEN_REQUEST);
 524       test_sequence_.push_back(base::RandInt(0, 1) ? PACED_PACKET_TEST
 525                                                    : NON_PACED_PACKET_TEST);
 526     }
 527     if (received_packets >= kMinimumReceivedPacketsForNATTest) {
 528       test_sequence_.push_back(TOKEN_REQUEST);
 529       test_sequence_.push_back(NAT_BIND_TEST);
 530       test_sequence_.push_back(TOKEN_REQUEST);
 531     }
 532   }
 533   TestPhaseComplete(READ_TIMED_OUT, net::ERR_FAILED);
 534 }
 535
 536 bool NetworkStats::TestPhaseComplete(Status status, int result) {
 537   // If there is no valid token, do nothing and delete self.
 538   // This includes all connection error, name resolve error, etc.
 539   if (write_state_ == WRITE_STATE_WRITE_PENDING) {
 540     UMA_HISTOGRAM_BOOLEAN("NetConnectivity5.TestFailed.WritePending", true);
 541   } else if (status == SUCCESS || status == READ_TIMED_OUT) {
 542     TestType current_test = test_sequence_[current_test_index_];
 543     DCHECK_LT(current_test, TEST_TYPE_MAX);
 544     if (current_test != TOKEN_REQUEST) {
 545       RecordHistograms(current_test);
 546     } else if (current_test_index_ > 0) {
 547       if (test_sequence_[current_test_index_ - 1] == NAT_BIND_TEST) {
 548         // We record the NATTestReceivedHistograms after the succeeding
 549         // TokenRequest.
 550         RecordNATTestReceivedHistograms(status);
 551       } else if (test_sequence_[current_test_index_ - 1] == PACKET_SIZE_TEST) {
 552         // We record the PacketSizeTestReceivedHistograms after the succeeding
 553         // TokenRequest.
 554         RecordPacketSizeTestReceivedHistograms(status);
 555       }
 556     }
 557
 558     // Move to the next test.
 559     current_test = GetNextTest();
 560     if (current_test_index_ <= maximum_tests_ && current_test < TEST_TYPE_MAX) {
 561       DVLOG(1) << "NetworkStat: Start Probe test: " << current_test;
 562       base::MessageLoop::current()->PostTask(
 563           FROM_HERE,
 564           base::Bind(&NetworkStats::StartOneTest, weak_factory_.GetWeakPtr()));
 565       return false;
 566     }
 567   }
 568
 569   // All tests are done.
 570   DoFinishCallback(result);
 571
 572   // Close the socket so that there are no more IO operations.
 573   if (socket_.get())
 574     socket_->Close();
 575
 576   DVLOG(1) << "NetworkStat: schedule delete self at test index "
 577            << current_test_index_;
 578   delete this;
 579   return true;
 580 }
 581
 582 NetworkStats::TestType NetworkStats::GetNextTest() {
 583   ++current_test_index_;
 584   if (current_test_index_ >= test_sequence_.size())
 585     return TEST_TYPE_MAX;
 586   return test_sequence_[current_test_index_];
 587 }
 588
 589 void NetworkStats::DoFinishCallback(int result) {
 590   if (!finished_callback_.is_null()) {
 591     net::CompletionCallback callback = finished_callback_;
 592     finished_callback_.Reset();
 593     callback.Run(result);
 594   }
 595 }
 596
 597 void NetworkStats::RecordHistograms(TestType test_type) {
 598   switch (test_type) {
 599     case START_PACKET_TEST:
 600     case NON_PACED_PACKET_TEST:
 601     case PACED_PACKET_TEST: {
 602       RecordInterArrivalHistograms(test_type);
 603       RecordPacketLossSeriesHistograms(test_type);
 604       RecordPacketsReceivedHistograms(test_type);
 605       // Only record RTT for these packet indices.
 606       uint32 rtt_indices[] = {0, 1, 2, 9, 19};
 607       for (uint32 i = 0; i < arraysize(rtt_indices); ++i) {
 608         if (rtt_indices[i] < packet_rtt_.size())
 609           RecordRTTHistograms(test_type, rtt_indices[i]);
 610       }
 611       RecordSendToLastRecvDelayHistograms(test_type);
 612       return;
 613     }
 614     case NAT_BIND_TEST:
 615       RecordSendToLastRecvDelayHistograms(test_type);
 616       return;
 617     case PACKET_SIZE_TEST:
 618       // No need to record RTT for PacketSizeTest.
 619       return;
 620     default:
 621       DVLOG(1) << "Unexpected test type " << test_type
 622                << " in RecordHistograms.";
 623   }
 624 }
 625
 626 void NetworkStats::RecordInterArrivalHistograms(TestType test_type) {
 627   DCHECK_NE(test_type, PACKET_SIZE_TEST);
 628   std::string histogram_name =
 629       base::StringPrintf("NetConnectivity5.%s.Sent%d.PacketDelay.%d.%dB",
 630                          kTestName[test_type],
 631                          maximum_sequential_packets_,
 632                          histogram_port_,
 633                          probe_packet_bytes_);
 634   // Record the time normalized to 20 packet inter-arrivals.
 635   DynamicHistogramTimes(histogram_name, inter_arrival_time_ * 20);
 636 }
 637
 638 void NetworkStats::RecordPacketsReceivedHistograms(TestType test_type) {
 639   DCHECK_NE(test_type, PACKET_SIZE_TEST);
 640   const char* test_name = kTestName[test_type];
 641   std::string histogram_prefix = base::StringPrintf(
 642       "NetConnectivity5.%s.Sent%d.", test_name, maximum_sequential_packets_);
 643   std::string histogram_suffix =
 644       base::StringPrintf(".%d.%dB", histogram_port_, probe_packet_bytes_);
 645   std::string name = histogram_prefix + "GotAPacket" + histogram_suffix;
 646   base::HistogramBase* histogram_pointer = base::BooleanHistogram::FactoryGet(
 647       name, base::HistogramBase::kUmaTargetedHistogramFlag);
 648   histogram_pointer->Add(packets_received_mask_.any());
 649
 650   DynamicHistogramEnumeration(
 651       histogram_prefix + "PacketsRecv" + histogram_suffix,
 652       packets_received_mask_.count(),
 653       maximum_sequential_packets_ + 1);
 654
 655   if (!packets_received_mask_.any())
 656     return;
 657
 658   base::HistogramBase* received_nth_packet_histogram =
 659       base::Histogram::FactoryGet(
 660           histogram_prefix + "RecvNthPacket" + histogram_suffix,
 661           1,
 662           maximum_sequential_packets_ + 1,
 663           maximum_sequential_packets_ + 2,
 664           base::HistogramBase::kUmaTargetedHistogramFlag);
 665
 666   int count = 0;
 667   for (size_t j = 0; j < maximum_sequential_packets_; ++j) {
 668     int packet_number = j + 1;
 669     if (packets_received_mask_.test(j)) {
 670       received_nth_packet_histogram->Add(packet_number);
 671       ++count;
 672     }
 673     std::string histogram_name =
 674         base::StringPrintf("%sNumRecvFromFirst%02dPackets%s",
 675                            histogram_prefix.c_str(),
 676                            packet_number,
 677                            histogram_suffix.c_str());
 678     DynamicHistogramEnumeration(histogram_name, count, packet_number + 1);
 679   }
 680 }
 681
 682 void NetworkStats::RecordNATTestReceivedHistograms(Status status) {
 683   const char* test_name = kTestName[NAT_BIND_TEST];
 684   bool test_result = status == SUCCESS;
 685   std::string middle_name = test_result ? "Connectivity.Success"
 686                                         : "Connectivity.Failure";
 687   // Record whether the HelloRequest got reply successfully.
 688   std::string histogram_name =
 689       base::StringPrintf("NetConnectivity5.%s.Sent%d.%s.%d.%dB",
 690                          test_name,
 691                          maximum_NAT_packets_,
 692                          middle_name.c_str(),
 693                          histogram_port_,
 694                          probe_packet_bytes_);
 695   uint32 bucket_count = std::min(maximum_NAT_idle_seconds_ + 2, 50U);
 696   DynamicHistogramCounts(histogram_name,
 697                          pacing_interval_.InSeconds(),
 698                          1,
 699                          maximum_NAT_idle_seconds_ + 1,
 700                          bucket_count);
 701
 702   // Record the NAT bind result only if the HelloRequest successfully got the
 703   // token and the first NAT test packet is received.
 704   if (!test_result || !packets_received_mask_.test(0))
 705     return;
 706
 707   middle_name = packets_received_mask_.test(1) ? "Bind.Success"
 708                                                : "Bind.Failure";
 709   histogram_name = base::StringPrintf("NetConnectivity5.%s.Sent%d.%s.%d.%dB",
 710                                       test_name,
 711                                       maximum_NAT_packets_,
 712                                       middle_name.c_str(),
 713                                       histogram_port_,
 714                                       probe_packet_bytes_);
 715   DynamicHistogramCounts(histogram_name,
 716                          pacing_interval_.InSeconds(),
 717                          1,
 718                          maximum_NAT_idle_seconds_ + 1,
 719                          bucket_count);
 720 }
 721
 722 void NetworkStats::RecordPacketSizeTestReceivedHistograms(Status status) {
 723   const char* test_name = kTestName[PACKET_SIZE_TEST];
 724   bool test_result = (status == SUCCESS && packets_received_mask_.test(0));
 725   std::string middle_name = test_result ? "Connectivity.Success"
 726                                         : "Connectivity.Failure";
 727   // Record whether the HelloRequest got reply successfully.
 728   std::string histogram_name =
 729       base::StringPrintf("NetConnectivity5.%s.%s.%d",
 730                          test_name,
 731                          middle_name.c_str(),
 732                          histogram_port_);
 733   base::HistogramBase* histogram_pointer = base::LinearHistogram::FactoryGet(
 734       histogram_name, kProbePacketBytes[kPacketSizeChoices - 1],
 735       ProbeMessage::kMaxProbePacketBytes, 60,
 736       base::HistogramBase::kUmaTargetedHistogramFlag);
 737   histogram_pointer->Add(bytes_for_packet_size_test_);
 738 }
 739
 740 void NetworkStats::RecordPacketLossSeriesHistograms(TestType test_type) {
 741   DCHECK_NE(test_type, PACKET_SIZE_TEST);
 742   const char* test_name = kTestName[test_type];
 743   // Build "NetConnectivity5.<TestName>.First6.SeriesRecv.<port>.<probe_size>"
 744   // histogram name. Total 3(tests) x 12 histograms.
 745   std::string series_acked_histogram_name =
 746       base::StringPrintf("NetConnectivity5.%s.First6.SeriesRecv.%d.%dB",
 747                          test_name,
 748                          histogram_port_,
 749                          probe_packet_bytes_);
 750   uint32 histogram_boundary = 1 << kCorrelatedLossPacketCount;
 751   uint32 correlated_packet_mask =
 752       (histogram_boundary - 1) & packets_received_mask_.to_ulong();
 753   DynamicHistogramEnumeration(
 754       series_acked_histogram_name, correlated_packet_mask, histogram_boundary);
 755
 756   // If we are running without a proxy, we'll generate an extra histogram with
 757   // the ".NoProxy" suffix.
 758   if (!has_proxy_server_) {
 759     series_acked_histogram_name.append(".NoProxy");
 760     DynamicHistogramEnumeration(series_acked_histogram_name,
 761                                 correlated_packet_mask,
 762                                 histogram_boundary);
 763   }
 764 }
 765
 766 void NetworkStats::RecordRTTHistograms(TestType test_type, uint32 index) {
 767   DCHECK_NE(test_type, PACKET_SIZE_TEST);
 768   DCHECK_LT(index, packet_rtt_.size());
 769
 770   if (!packets_received_mask_.test(index))
 771     return;  // Probe packet never received.
 772
 773   std::string rtt_histogram_name = base::StringPrintf(
 774       "NetConnectivity5.%s.Sent%d.Success.RTT.Packet%02d.%d.%dB",
 775       kTestName[test_type],
 776       maximum_sequential_packets_,
 777       index + 1,
 778       histogram_port_,
 779       probe_packet_bytes_);
 780   DynamicHistogramTimes(rtt_histogram_name, packet_rtt_[index]);
 781 }
 782
 783 void NetworkStats::RecordSendToLastRecvDelayHistograms(TestType test_type) {
 784   DCHECK_NE(test_type, PACKET_SIZE_TEST);
 785   if (packets_received_mask_.count() < 2)
 786     return;  // Too few packets are received.
 787   uint32 packets_sent = test_type == NAT_BIND_TEST
 788       ? maximum_NAT_packets_ : maximum_sequential_packets_;
 789   std::string histogram_name = base::StringPrintf(
 790       "NetConnectivity5.%s.Sent%d.SendToLastRecvDelay.%d.%dB",
 791       kTestName[test_type],
 792       packets_sent,
 793       histogram_port_,
 794       probe_packet_bytes_);
 795   base::TimeDelta send_to_last_recv_time =
 796       std::max(last_arrival_time_ - probe_request_time_ -
 797                    pacing_interval_ * (packets_sent - 1),
 798                base::TimeDelta::FromMilliseconds(0));
 799   DynamicHistogramTimes(histogram_name, send_to_last_recv_time);
 800 }
 801
 802 // ProxyDetector methods and members.
 803 ProxyDetector::ProxyDetector(net::ProxyService* proxy_service,
 804                              const net::HostPortPair& server_address,
 805                              OnResolvedCallback callback)
 806     : proxy_service_(proxy_service),
 807       server_address_(server_address),
 808       callback_(callback),
 809       has_pending_proxy_resolution_(false) {}
 810
 811 ProxyDetector::~ProxyDetector() {
 812   CHECK(!has_pending_proxy_resolution_);
 813 }
 814
 815 void ProxyDetector::StartResolveProxy() {
 816   std::string url =
 817       base::StringPrintf("https://%s", server_address_.ToString().c_str());
 818   GURL gurl(url);
 819
 820   has_pending_proxy_resolution_ = true;
 821   DCHECK(proxy_service_);
 822   int rv = proxy_service_->ResolveProxy(
 823       gurl,
 824       net::LOAD_NORMAL,
 825       &proxy_info_,
 826       base::Bind(&ProxyDetector::OnResolveProxyComplete,
 827                  base::Unretained(this)),
 828       NULL,
 829       NULL,
 830       net::BoundNetLog());
 831   if (rv != net::ERR_IO_PENDING)
 832     OnResolveProxyComplete(rv);
 833 }
 834
 835 void ProxyDetector::OnResolveProxyComplete(int result) {
 836   has_pending_proxy_resolution_ = false;
 837   bool has_proxy_server =
 838       (result == net::OK && proxy_info_.proxy_server().is_valid() &&
 839        !proxy_info_.proxy_server().is_direct());
 840
 841   OnResolvedCallback callback = callback_;
 842   BrowserThread::PostTask(
 843       BrowserThread::IO, FROM_HERE, base::Bind(callback, has_proxy_server));
 844
 845   // TODO(rtenneti): Will we leak if ProxyResolve is cancelled (or proxy
 846   // resolution never completes).
 847   delete this;
 848 }
 849
 850 void CollectNetworkStats(const std::string& network_stats_server,
 851                          IOThread* io_thread) {
 852   if (network_stats_server.empty())
 853     return;
 854
 855   // If we are not on IO Thread, then post a task to call CollectNetworkStats on
 856   // IO Thread.
 857   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
 858     BrowserThread::PostTask(
 859         BrowserThread::IO,
 860         FROM_HERE,
 861         base::Bind(&CollectNetworkStats, network_stats_server, io_thread));
 862     return;
 863   }
 864
 865   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 866
 867   if (net::NetworkChangeNotifier::IsOffline()) {
 868     return;
 869   }
 870
 871   CR_DEFINE_STATIC_LOCAL(scoped_refptr<base::FieldTrial>, trial, ());
 872   static bool collect_stats = false;
 873
 874   if (!trial.get()) {
 875     // Set up a field trial to collect network stats for UDP.
 876     const base::FieldTrial::Probability kDivisor = 1000;
 877
 878     // Enable the connectivity testing for 0.5% of the users in stable channel.
 879     base::FieldTrial::Probability probability_per_group = kDivisor / 200;
 880
 881     chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
 882     if (channel == chrome::VersionInfo::CHANNEL_CANARY) {
 883       // Enable the connectivity testing for 50% of the users in canary channel.
 884       probability_per_group = kDivisor / 2;
 885     } else if (channel == chrome::VersionInfo::CHANNEL_DEV) {
 886       // Enable the connectivity testing for 10% of the users in dev channel.
 887       probability_per_group = kDivisor / 10;
 888     } else if (channel == chrome::VersionInfo::CHANNEL_BETA) {
 889       // Enable the connectivity testing for 1% of the users in beta channel.
 890       probability_per_group = kDivisor / 100;
 891     }
 892
 893     // After July 31, 2014 builds, it will always be in default group
 894     // (disable_network_stats).
 895     trial = base::FieldTrialList::FactoryGetFieldTrial(
 896         "NetworkConnectivity", kDivisor, "disable_network_stats",
 897         2014, 7, 31, base::FieldTrial::SESSION_RANDOMIZED, NULL);
 898
 899     // Add option to collect_stats for NetworkConnectivity.
 900     int collect_stats_group =
 901         trial->AppendGroup("collect_stats", probability_per_group);
 902     if (trial->group() == collect_stats_group)
 903       collect_stats = true;
 904   }
 905
 906   if (!collect_stats)
 907     return;
 908
 909   // Run test kMaxNumberOfTests times.
 910   const size_t kMaxNumberOfTests = INT_MAX;
 911   static size_t number_of_tests_done = 0;
 912   if (number_of_tests_done > kMaxNumberOfTests)
 913     return;
 914   ++number_of_tests_done;
 915
 916   net::HostResolver* host_resolver = io_thread->globals()->host_resolver.get();
 917   DCHECK(host_resolver);
 918
 919   uint32 port_index = base::RandInt(0, arraysize(kPorts) - 1);
 920   uint16 histogram_port = kPorts[port_index];
 921   net::HostPortPair server_address(network_stats_server, histogram_port);
 922
 923   net::ProxyService* proxy_service =
 924       io_thread->globals()->system_proxy_service.get();
 925   DCHECK(proxy_service);
 926
 927   ProxyDetector::OnResolvedCallback callback = base::Bind(
 928       &StartNetworkStatsTest, host_resolver, server_address, histogram_port);
 929
 930   ProxyDetector* proxy_client =
 931       new ProxyDetector(proxy_service, server_address, callback);
 932   proxy_client->StartResolveProxy();
 933 }
 934
 935 void StartNetworkStatsTest(net::HostResolver* host_resolver,
 936                            const net::HostPortPair& server_address,
 937                            uint16 histogram_port,
 938                            bool has_proxy_server) {
 939   int probe_choice = base::RandInt(0, kPacketSizeChoices - 1);
 940
 941   DCHECK_LE(ProbeMessage::kMaxProbePacketBytes, kMaxMessageSize);
 942   // Pick a packet size between 1200 and kMaxProbePacketBytes bytes.
 943   uint32 bytes_for_packet_size_test =
 944       base::RandInt(kProbePacketBytes[kPacketSizeChoices - 1],
 945                     ProbeMessage::kMaxProbePacketBytes);
 946
 947   // |udp_stats_client| is owned and deleted in the class NetworkStats.
 948   NetworkStats* udp_stats_client =
 949       new NetworkStats(net::ClientSocketFactory::GetDefaultFactory());
 950   udp_stats_client->Start(host_resolver,
 951                           server_address,
 952                           histogram_port,
 953                           has_proxy_server,
 954                           kProbePacketBytes[probe_choice],
 955                           bytes_for_packet_size_test,
 956                           net::CompletionCallback());
 957 }
 958
 959 }  // namespace chrome_browser_net