[Clean-up] Remove NetworkStats code, which has been dead code since July 2014.

chrome/browser/net/network_stats_unittest.cc

Index: chrome/browser/net/network_stats_unittest.cc
diff --git a/chrome/browser/net/network_stats_unittest.cc b/chrome/browser/net/network_stats_unittest.cc
deleted file mode 100644
index 52c03f1e00129858e132c4fa3490fad49196655c..0000000000000000000000000000000000000000
--- a/chrome/browser/net/network_stats_unittest.cc
+++ /dev/null
@@ -1,410 +0,0 @@
-// 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/message_loop.h"
-#include "chrome/browser/net/network_stats.h"
-#include "net/base/net_errors.h"
-#include "net/base/network_change_notifier.h"
-#include "net/base/test_completion_callback.h"
-#include "net/dns/host_resolver.h"
-#include "net/dns/mock_host_resolver.h"
-#include "net/socket/socket_test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-using std::string;
-
-namespace chrome_browser_net {
-
-class NetworkStatsTest : public PlatformTest {
- public:
-  NetworkStatsTest() {}
-
- protected:
-  void SetUp() override {
-    net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
-    base::MessageLoop::current()->RunUntilIdle();
-    mock_writes_.clear();
-    mock_reads_.clear();
-  }
-
-  void TearDown() override {
-    net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
-    // Empty the current queue.
-    base::MessageLoop::current()->RunUntilIdle();
-    PlatformTest::TearDown();
-  }
-
-  void CreateToken(uint64 timestamp_micros,
-                   const string& hash,
-                   ProbePacket_Token* token) {
-    token->set_timestamp_micros(timestamp_micros);
-    token->mutable_hash()->assign(hash);
-  }
-
-  // DeterministicMockData defines the exact sequence of the read/write
-  // operations (specified by the last parameter of MockRead/MockWrite).
-  // |io_mode_write| is the IO mode for writing only. Reading is always async.
-  void MakeDeterministicMockData(uint32 max_tests,
-                                 uint32 max_probe_packets,
-                                 uint32 probe_bytes,
-                                 net::IoMode io_mode_write) {
-    // Only allow 0 or 1 test because the test 2 in NetworkStats is random.
-    DCHECK_LT(max_tests, 2U);
-    outputs_.resize(10);
-    ProbePacket probe_packet;
-    ProbeMessage probe_message;
-    probe_message.SetPacketHeader(ProbePacket_Type_HELLO_REQUEST,
-                                  &probe_packet);
-    probe_packet.set_group_id(0);
-    outputs_[0] = probe_message.MakeEncodedPacket(probe_packet);
-    mock_writes_.clear();
-    mock_writes_.push_back(net::MockWrite(
-        io_mode_write, &outputs_[0][0], outputs_[0].size(), 0));
-    // Add one probe_request.
-    probe_packet = ProbePacket();  // Clear all content.
-    ProbePacket_Token token;
-    CreateToken(1L, "1010", &token);
-    probe_message.GenerateProbeRequest(
-        token, 1, probe_bytes, 0, max_probe_packets, &probe_packet);
-    outputs_[1] = probe_message.MakeEncodedPacket(probe_packet);
-    mock_writes_.push_back(net::MockWrite(
-        io_mode_write, &outputs_[1][0], outputs_[1].size(), 2));
-
-    inputs_.resize(10);
-    mock_reads_.clear();
-    // Add a hello reply.
-    probe_packet = ProbePacket();  // Clear all content.
-    probe_message.SetPacketHeader(ProbePacket_Type_HELLO_REPLY, &probe_packet);
-    probe_packet.set_group_id(0);
-    CreateToken(1L, "1010", probe_packet.mutable_token());
-    inputs_[0] = probe_message.MakeEncodedPacket(probe_packet);
-    mock_reads_.push_back(
-        net::MockRead(net::ASYNC, &inputs_[0][0], inputs_[0].size(), 1));
-
-    for (uint32 i = 0; i < max_probe_packets; ++i) {
-      // Add a probe reply.
-      probe_packet = ProbePacket();  // Clear all content.
-      probe_message.SetPacketHeader(ProbePacket_Type_PROBE_REPLY,
-                                    &probe_packet);
-      int padding_size = probe_bytes - probe_packet.ByteSize() - 8;
-      probe_packet.mutable_padding()->append(
-          std::string(std::max(0, padding_size), 0));
-      probe_packet.mutable_header()->set_checksum(0);
-      probe_packet.set_group_id(1);
-      probe_packet.set_packet_index(i);
-      inputs_[1 + i] = probe_message.MakeEncodedPacket(probe_packet);
-      mock_reads_.push_back(net::MockRead(
-          net::ASYNC, &inputs_[1 + i][0], inputs_[1 + i].size(), 3 + i));
-    }
-  }
-
-  // Test NetworkStats::Start(...) method.
-  void TestStart(bool has_proxy,
-                 uint32 max_tests,
-                 uint32 max_probe_packets,
-                 uint32 bytes,
-                 net::IoMode io_mode) {
-    net::DeterministicMockClientSocketFactory mock_socket_factory;
-    MakeDeterministicMockData(max_tests, max_probe_packets, bytes, io_mode);
-    net::DeterministicSocketData test_data(
-        &mock_reads_[0], mock_reads_.size(),
-        &mock_writes_[0], mock_writes_.size());
-    mock_socket_factory.AddSocketDataProvider(&test_data);
-    NetworkStats* udp_stats_client = new NetworkStats(&mock_socket_factory);
-    udp_stats_client->maximum_tests_ = max_tests;
-    udp_stats_client->maximum_sequential_packets_ = max_probe_packets;
-
-    net::TestCompletionCallback cb;
-    scoped_ptr<net::MockHostResolver> host_resolver(
-        new net::MockHostResolver());
-    net::HostPortPair host_port_pair;
-    EXPECT_TRUE(udp_stats_client->Start(host_resolver.get(),
-                                        host_port_pair,
-                                        9999,
-                                        has_proxy,
-                                        bytes,
-                                        bytes,
-                                        cb.callback()));
-    int num_packets_run = (max_tests + 1) * 2 + max_probe_packets - 1;
-    test_data.RunFor(num_packets_run);
-    int rv = cb.WaitForResult();
-    // Check there were no errors during connect/write/read to echo UDP server.
-    EXPECT_EQ(0, rv);
-  }
-
-  // Make one write and then |max_probe_packets| reads.
-  void MakeDelayedMockData(NetworkStats::TestType test_type,
-                           uint32 probe_bytes,
-                           uint32 pacing_interval_micros,
-                           uint32 max_probe_packets,
-                           net::IoMode io_mode) {
-    outputs_.resize(1);
-    ProbePacket probe_packet;
-    ProbeMessage probe_message;
-    mock_writes_.clear();
-    ProbePacket_Token token;
-    CreateToken(2L, "2a2b", &token);
-    switch (test_type) {
-      case NetworkStats::PACKET_SIZE_TEST:
-      case NetworkStats::NON_PACED_PACKET_TEST:
-        pacing_interval_micros = 0;
-        break;
-      case NetworkStats::NAT_BIND_TEST:
-        // For NAT_BIND_TEST, we always set this to 1000000 to avoid the
-        // randomness in NetworkStats::SendProbeRequest() and to match
-        // the value chosen in TestStartOneTest() below.
-        pacing_interval_micros = 1000000;
-        break;
-      default: {}  // Do nothing here.
-    }
-    probe_message.GenerateProbeRequest(token,
-                                       1,  // current_test_index_ = 1.
-                                       probe_bytes,
-                                       pacing_interval_micros,
-                                       max_probe_packets,
-                                       &probe_packet);
-    outputs_[0] = probe_message.MakeEncodedPacket(probe_packet);
-    mock_writes_.push_back(
-        net::MockWrite(io_mode, &outputs_[0][0], outputs_[0].size()));
-
-    inputs_.resize(max_probe_packets);
-    mock_reads_.clear();
-    for (uint32 i = 0; i < max_probe_packets; ++i) {
-      // Add a probe reply.
-      probe_packet = ProbePacket();  // Clear all content.
-      probe_message.SetPacketHeader(ProbePacket_Type_PROBE_REPLY,
-                                    &probe_packet);
-      int padding_size = probe_bytes - probe_packet.ByteSize() - 8;
-      probe_packet.mutable_padding()->append(
-          std::string(std::max(0, padding_size), 0));
-      probe_packet.mutable_header()->set_checksum(0);
-      probe_packet.set_group_id(1);
-      probe_packet.set_packet_index(i);
-      inputs_[i] = probe_message.MakeEncodedPacket(probe_packet);
-      mock_reads_.push_back(
-          net::MockRead(io_mode, &inputs_[i][0], inputs_[i].size()));
-    }
-  }
-
-  // Test NetworkStats::StartOneTest(...) method.
-  void TestStartOneTest(bool has_proxy,
-                        NetworkStats::TestType test_type,
-                        uint32 bytes,
-                        uint32 interval_micros,
-                        uint32 max_probe_packets,
-                        net::IoMode io_mode) {
-
-    net::MockClientSocketFactory mock_socket_factory;
-    MakeDelayedMockData(
-        test_type, bytes, interval_micros, max_probe_packets, io_mode);
-    net::DelayedSocketData test_data(1,
-                                     &mock_reads_[0],
-                                     mock_reads_.size(),
-                                     &mock_writes_[0],
-                                     mock_writes_.size());
-    mock_socket_factory.AddSocketDataProvider(&test_data);
-    NetworkStats* udp_stats_client = new NetworkStats(&mock_socket_factory);
-    udp_stats_client->maximum_tests_ = 1;  // Only do one probe at a time.
-    udp_stats_client->maximum_sequential_packets_ = max_probe_packets;
-    udp_stats_client->maximum_NAT_packets_ = max_probe_packets;
-    // For NAT_BIND_TEST, we always set this to 1 (second) to avoid the
-    // randomness in NetworkStats::SendProbeRequest().
-    udp_stats_client->maximum_NAT_idle_seconds_ = 1;
-    udp_stats_client->start_test_after_connect_ = false;
-    udp_stats_client->inter_arrival_time_ =
-        base::TimeDelta::FromMicroseconds(interval_micros);
-    CreateToken(2L, "2a2b", &udp_stats_client->token_);
-
-    net::TestCompletionCallback cb;
-    scoped_ptr<net::MockHostResolver> host_resolver(
-        new net::MockHostResolver());
-    net::HostPortPair host_port_pair;
-    EXPECT_TRUE(udp_stats_client->Start(host_resolver.get(),
-                                        host_port_pair,
-                                        9999,
-                                        has_proxy,
-                                        bytes,
-                                        bytes,
-                                        cb.callback()));
-    // Test need to be added after Start() because Start() will reset
-    // test_sequence_
-    udp_stats_client->test_sequence_.push_back(test_type);
-    udp_stats_client->current_test_index_ = 1;
-    // Wait for host resolving and check if there were no errors during
-    // connect/write/read to UDP server.
-    int rv = cb.WaitForResult();
-    EXPECT_EQ(0, rv);
-    udp_stats_client->ReadData();
-    udp_stats_client->StartOneTest();
-    rv = cb.WaitForResult();
-    EXPECT_EQ(0, rv);
-  }
-
-  base::MessageLoopForIO message_loop_;
-  std::vector<std::string> inputs_;
-  std::vector<std::string> outputs_;
-  std::vector<net::MockRead> mock_reads_;
-  std::vector<net::MockWrite> mock_writes_;
-};
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasProxyGetToken) {
-  TestStart(true, 0, 1, 100, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyGetTokenSync) {
-  TestStart(false, 0, 1, 500, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTest) {
-  TestStart(false, 1, 1, 100, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTestSync) {
-  TestStart(false, 1, 1, 100, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasProxyOneTest) {
-  TestStart(true, 1, 1, 100, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasProxyOneTestSync) {
-  TestStart(true, 1, 1, 100, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest500BHasProxyOneTest) {
-  TestStart(true, 1, 1, 500, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyOneTestSync) {
-  TestStart(false, 1, 1, 500, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest500BHasNoProxyOneTest) {
-  TestStart(false, 1, 1, 500, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest500BHasProxyOneTestSync) {
-  TestStart(true, 1, 1, 500, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTest) {
-  TestStart(true, 1, 1, 1200, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest1200BHasNoProxyOneTestSync) {
-  TestStart(false, 1, 1, 1200, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest1200BHasNoProxyOneTest) {
-  TestStart(false, 1, 1, 1200, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTestSync) {
-  TestStart(true, 1, 1, 1200, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest100BHasNoProxyOneTestMultiPackets) {
-  TestStart(false, 1, 4, 100, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, ProbeTest1200BHasProxyOneTestMultiPacketsSync) {
-  TestStart(true, 1, 4, 1200, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest100BHasProxy) {
-  TestStartOneTest(
-      true, NetworkStats::NON_PACED_PACKET_TEST, 100, 0, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest100BHasNoProxySync) {
-  TestStartOneTest(
-      false, NetworkStats::NON_PACED_PACKET_TEST, 100, 0, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest500BHasNoProxy) {
-  TestStartOneTest(
-      false, NetworkStats::NON_PACED_PACKET_TEST, 500, 3, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest1200BHasProxySync) {
-  TestStartOneTest(
-      true, NetworkStats::NON_PACED_PACKET_TEST, 1200, 1, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest500BHasNoProxyMulti) {
-  TestStartOneTest(
-      false, NetworkStats::NON_PACED_PACKET_TEST, 500, 2, 3, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartNonPacedTest1200BHasProxySyncMulti) {
-  TestStartOneTest(
-      true, NetworkStats::NON_PACED_PACKET_TEST, 1200, 1, 4, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest100BHasProxy) {
-  TestStartOneTest(
-      true, NetworkStats::PACED_PACKET_TEST, 100, 0, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest100BHasNoProxySync) {
-  TestStartOneTest(
-      false, NetworkStats::PACED_PACKET_TEST, 100, 0, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest500BHasNoProxy) {
-  TestStartOneTest(
-      false, NetworkStats::PACED_PACKET_TEST, 500, 3, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest1200BHasProxySync) {
-  TestStartOneTest(
-      true, NetworkStats::PACED_PACKET_TEST, 1200, 1, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest500BHasNoProxyMulti) {
-  TestStartOneTest(
-      false, NetworkStats::PACED_PACKET_TEST, 500, 2, 3, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartPacedTest1200BHasProxySyncMulti) {
-  TestStartOneTest(
-      true, NetworkStats::PACED_PACKET_TEST, 1200, 1, 4, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartNATBindTest100BHasProxy) {
-  TestStartOneTest(true, NetworkStats::NAT_BIND_TEST, 100, 0, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartNATBindTest100BHasNoProxySync) {
-  TestStartOneTest(
-      false, NetworkStats::NAT_BIND_TEST, 100, 3, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartNATBindTest500BHasNoProxy) {
-  TestStartOneTest(false, NetworkStats::NAT_BIND_TEST, 500, 0, 2, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartNATBindTest1200BHasProxySync) {
-  TestStartOneTest(
-      true, NetworkStats::NAT_BIND_TEST, 1200, 3, 2, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartPacketSizeTest1500BHasProxy) {
-  TestStartOneTest(
-      true, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::ASYNC);
-}
-
-TEST_F(NetworkStatsTest, StartPacketSizeTest1500HasNoProxySync) {
-  TestStartOneTest(
-      false, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::SYNCHRONOUS);
-}
-
-TEST_F(NetworkStatsTest, StartPacketSizeTest1500BHasNoProxy) {
-  TestStartOneTest(
-      false, NetworkStats::PACKET_SIZE_TEST, 1500, 0, 1, net::ASYNC);
-}
-
-}  // namespace chrome_browser_net