Componentize renderer side of DNS prefetching.

chrome/renderer/net/predictor_queue_unittest.cc

Index: chrome/renderer/net/predictor_queue_unittest.cc
diff --git a/chrome/renderer/net/predictor_queue_unittest.cc b/chrome/renderer/net/predictor_queue_unittest.cc
deleted file mode 100644
index 98d4bde3403ebec33a5812f9131e715c133b770f..0000000000000000000000000000000000000000
--- a/chrome/renderer/net/predictor_queue_unittest.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright (c) 2010 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 <sstream>
-
-#include "chrome/renderer/net/predictor_queue.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Single threaded tests of DnsQueue functionality.
-
-namespace {
-
-class DnsQueueTest : public testing::Test {
-};
-
-// Define a helper class that does Push'es and Pop's of numbers.
-// This makes it easy to test a LOT of reads, and keep the expected Pop
-// value in sync with the Push value.
-class DnsQueueSequentialTester {
- public:
-  DnsQueueSequentialTester(DnsQueue& buffer, int32 read_counter = 0,
-                           int32 write_counter = 0);
-
-  // Return of false means buffer was full, or would not take entry.
-  bool Push(void);  // Push the string value of next number.
-
-  // Return of false means buffer returned wrong value.
-  bool Pop(void);  // Validate string value of next read.
-
- private:
-  DnsQueue* buffer_;
-  int32 read_counter_;  // expected value of next read string.
-  int32 write_counter_;  // Numerical value to write next string.
-  DISALLOW_COPY_AND_ASSIGN(DnsQueueSequentialTester);
-};
-
-
-DnsQueueSequentialTester::DnsQueueSequentialTester(
-  DnsQueue& buffer, int32 read_counter, int32 write_counter)
-    : buffer_(&buffer),
-      read_counter_(read_counter),
-      write_counter_(write_counter) {
-}
-
-bool DnsQueueSequentialTester::Push(void) {
-  std::ostringstream value;
-  value << write_counter_;
-
-  // Exercise both write methods intermittently.
-  DnsQueue::PushResult result = (write_counter_ % 2) ?
-       buffer_->Push(value.str().c_str(), value.str().size()) :
-       buffer_->Push(value.str());
-  if (DnsQueue::SUCCESSFUL_PUSH == result)
-    write_counter_++;
-  return DnsQueue::OVERFLOW_PUSH != result;
-}
-
-bool DnsQueueSequentialTester::Pop(void) {
-  std::string string;
-  if (buffer_->Pop(&string)) {
-    std::ostringstream expected_value;
-    expected_value << read_counter_++;
-    EXPECT_STREQ(expected_value.str().c_str(), string.c_str())
-        << "Pop did not match write for value " << read_counter_;
-    return true;
-  }
-  return false;
-}
-
-
-TEST(DnsQueueTest, BufferUseCheck) {
-  // Use a small buffer so we can see that we can't write a string as soon as it
-  // gets longer than one less than the buffer size.  The extra empty character
-  // is used to keep read and write pointers from overlapping when buffer is
-  // full.  This shows the buffer size can constrain writes (and we're not
-  // scribbling all over memory).
-  const int buffer_size = 3;  // Just room for 2 digts plus '\0' plus blank.
-  std::string string;
-  DnsQueue buffer(buffer_size);
-  DnsQueueSequentialTester tester(buffer);
-
-  EXPECT_FALSE(tester.Pop()) << "Pop from empty buffer succeeded";
-
-  int i;
-  for (i = 0; i < 102; i++) {
-    if (!tester.Push())
-      break;  // String was too large.
-    EXPECT_TRUE(tester.Pop()) << "Unable to read back data " << i;
-    EXPECT_FALSE(buffer.Pop(&string))
-                << "read from empty buffer not flagged";
-  }
-
-  EXPECT_GE(i, 100) << "Can't write 2 digit strings in 4 character buffer";
-  EXPECT_LT(i, 101) << "We wrote 3 digit strings into a 4 character buffer";
-}
-
-TEST(DnsQueueTest, SubstringUseCheck) {
-  // Verify that only substring is written/read.
-  const int buffer_size = 100;
-  const char big_string[] = "123456789";
-  std::string string;
-  DnsQueue buffer(buffer_size);
-
-  EXPECT_FALSE(buffer.Pop(&string)) << "Initial buffer not empty";
-
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push(big_string, 3))
-      << "Can't write string";
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push(big_string, 0))
-      << "Can't write null string";
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push(big_string, 5))
-      << "Can't write string";
-
-  EXPECT_TRUE(buffer.Pop(&string)) << "Filled buffer marked as empty";
-  EXPECT_STREQ(string.c_str(), "123") << "Can't read actual data";
-  EXPECT_TRUE(buffer.Pop(&string)) << "Filled buffer marked as empty";
-  EXPECT_STREQ(string.c_str(), "") << "Can't read null string";
-  EXPECT_TRUE(buffer.Pop(&string)) << "Filled buffer marked as empty";
-  EXPECT_STREQ(string.c_str(), "12345") << "Can't read actual data";
-
-  EXPECT_FALSE(buffer.Pop(&string))
-              << "read from empty buffer not flagged";
-}
-
-TEST(DnsQueueTest, SizeCheck) {
-  // Verify that size is correctly accounted for in buffer.
-  const int buffer_size = 100;
-  std::string input_string = "Hello";
-  std::string string;
-  DnsQueue buffer(buffer_size);
-
-  EXPECT_EQ(0U, buffer.Size());
-  EXPECT_FALSE(buffer.Pop(&string));
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push(input_string));
-  EXPECT_EQ(1U, buffer.Size());
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push("Hi There"));
-  EXPECT_EQ(2U, buffer.Size());
-  EXPECT_TRUE(buffer.Pop(&string));
-  EXPECT_EQ(1U, buffer.Size());
-  EXPECT_TRUE(buffer.Pop(&string));
-  EXPECT_EQ(0U, buffer.Size());
-  EXPECT_EQ(DnsQueue::SUCCESSFUL_PUSH, buffer.Push(input_string));
-  EXPECT_EQ(1U, buffer.Size());
-
-  // Check to see that the first string, if repeated, is discarded.
-  EXPECT_EQ(DnsQueue::REDUNDANT_PUSH, buffer.Push(input_string));
-  EXPECT_EQ(1U, buffer.Size());
-}
-
-TEST(DnsQueueTest, FillThenEmptyCheck) {
-  // Use a big buffer so we'll get a bunch of writes in.
-  // This tests to be sure the buffer holds many strings.
-  // We also make sure they all come out intact.
-  const size_t buffer_size = 1000;
-  size_t byte_usage_counter = 1;  // Separation character between pointer.
-  DnsQueue buffer(buffer_size);
-  DnsQueueSequentialTester tester(buffer);
-
-  size_t write_success;
-  for (write_success = 0; write_success < buffer_size; write_success++) {
-    if (!tester.Push())
-      break;
-    EXPECT_EQ(buffer.Size(), write_success + 1);
-    if (write_success > 99)
-      byte_usage_counter += 4;  // 3 digit plus '\0'.
-    else if (write_success > 9)
-      byte_usage_counter += 3;  // 2 digits plus '\0'.
-    else
-      byte_usage_counter += 2;  // Digit plus '\0'.
-  }
-  EXPECT_LE(byte_usage_counter, buffer_size)
-      << "Written data exceeded buffer size";
-  EXPECT_GE(byte_usage_counter, buffer_size - 4)
-      << "Buffer does not appear to have filled";
-
-  EXPECT_GE(write_success, 10U) << "Couldn't even write 10 one digit strings "
-      "in " << buffer_size << " byte buffer";
-
-
-  while (1) {
-    if (!tester.Pop())
-      break;
-    write_success--;
-  }
-  EXPECT_EQ(write_success, 0U) << "Push and Pop count were different";
-
-  EXPECT_FALSE(tester.Pop()) << "Read from empty buffer succeeded";
-}
-
-TEST(DnsQueueTest, ClearCheck) {
-  // Use a big buffer so we'll get a bunch of writes in.
-  const size_t buffer_size = 1000;
-  DnsQueue buffer(buffer_size);
-  std::string string("ABC");
-  DnsQueueSequentialTester tester(buffer);
-
-  size_t write_success;
-  for (write_success = 0; write_success < buffer_size; write_success++) {
-    if (!tester.Push())
-      break;
-    EXPECT_EQ(buffer.Size(), write_success + 1);
-  }
-
-  buffer.Clear();
-  EXPECT_EQ(buffer.Size(), 0U);
-
-  size_t write_success2;
-  for (write_success2 = 0; write_success2 < buffer_size; write_success2++) {
-    if (!tester.Push())
-      break;
-    EXPECT_EQ(buffer.Size(), write_success2 + 1);
-  }
-
-  for (; write_success2 > 0; write_success2--) {
-    EXPECT_EQ(buffer.Size(), write_success2);
-    EXPECT_TRUE(buffer.Pop(&string));
-  }
-
-  EXPECT_EQ(buffer.Size(), 0U);
-  buffer.Clear();
-  EXPECT_EQ(buffer.Size(), 0U);
-}
-
-TEST(DnsQueueTest, WrapOnVariousSubstrings) {
-  // Use a prime number for the allocated buffer size so that we tend
-  // to exercise all possible edge conditions (in circular text buffer).
-  // Once we're over 10 writes, all our strings are 2 digits long,
-  // with a '\0' terminator added making 3 characters per write.
-  // Since 3 is relatively prime to 23, we'll soon wrap (about
-  // every 6 writes).  Hence after 18 writes, we'll have tested all
-  // edge conditions.  We'll first do this where we empty the buffer
-  // after each write, and then again where there are some strings
-  // still in the buffer after each write.
-  const int prime_number = 23;
-  // Circular buffer needs an extra extra space to distinguish full from empty.
-  const int buffer_size = prime_number - 1;
-  DnsQueue buffer(buffer_size);
-  DnsQueueSequentialTester tester(buffer);
-
-  // First test empties between each write. Second loop
-  // has writes for each pop.  Third has three pushes per pop.
-  // Third has two items pending during each write.
-  for (int j = 0; j < 3; j++) {
-    // Each group does 30 tests, which is more than 10+18
-    // which was needed to get into the thorough testing zone
-    // mentioned above.
-    for (int i = 0; i < 30; i++) {
-      EXPECT_TRUE(tester.Push()) << "write failed with only " << j
-                                    << " blocks in buffer";
-      EXPECT_TRUE(tester.Pop()) << "Unable to read back data ";
-    }
-    EXPECT_TRUE(tester.Push());
-  }
-
-  // Read back the accumulated 3 extra blocks.
-  EXPECT_TRUE(tester.Pop());
-  EXPECT_TRUE(tester.Pop());
-  EXPECT_TRUE(tester.Pop());
-  EXPECT_FALSE(tester.Pop());
-}
-
-};  // namespace