Convert DnsTransactionTest to use SequencedSocketData

net/dns/dns_transaction_unittest.cc

Index: net/dns/dns_transaction_unittest.cc
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index 2693a5ca9cf4dbf3126c244e1923f5800a616c2e..0c14561a5e463b9f496fee68f53b52874ee505fd 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -46,12 +46,12 @@ class DnsSocketData {
       *length = base::HostToNet16(query_->io_buffer()->size());
       writes_.push_back(MockWrite(mode,
                                   reinterpret_cast<const char*>(length.get()),
-                                  sizeof(uint16)));
+                                  sizeof(uint16), num_reads_and_writes()));
       lengths_.push_back(length.release());
     }
-    writes_.push_back(MockWrite(mode,
-                                query_->io_buffer()->data(),
-                                query_->io_buffer()->size()));
+    writes_.push_back(MockWrite(mode, query_->io_buffer()->data(),
+                                query_->io_buffer()->size(),
+                                num_reads_and_writes()));
   }
   ~DnsSocketData() {}
 
@@ -66,12 +66,12 @@ class DnsSocketData {
       *length = base::HostToNet16(tcp_length);
       reads_.push_back(MockRead(mode,
                                 reinterpret_cast<const char*>(length.get()),
-                                sizeof(uint16)));
+                                sizeof(uint16), num_reads_and_writes()));
       lengths_.push_back(length.release());
     }
-    reads_.push_back(MockRead(mode,
-                              response->io_buffer()->data(),
-                              response->io_buffer()->size()));
+    reads_.push_back(MockRead(mode, response->io_buffer()->data(),
+                              response->io_buffer()->size(),
+                              num_reads_and_writes()));
     responses_.push_back(response.release());
   }
 
@@ -102,19 +102,20 @@ class DnsSocketData {
 
   // Add error response.
   void AddReadError(int error, IoMode mode) {
-    reads_.push_back(MockRead(mode, error));
+    reads_.push_back(MockRead(mode, error, num_reads_and_writes()));
   }
 
   // Build, if needed, and return the SocketDataProvider. No new responses
   // should be added afterwards.
-  SocketDataProvider* GetProvider() {
+  SequencedSocketData* GetProvider() {
     if (provider_.get())
       return provider_.get();
     // Terminate the reads with ERR_IO_PENDING to prevent overrun and default to
     // timeout.
-    reads_.push_back(MockRead(ASYNC, ERR_IO_PENDING));
-    provider_.reset(new DelayedSocketData(1, &reads_[0], reads_.size(),
-                                          &writes_[0], writes_.size()));
+    reads_.push_back(
+        MockRead(ASYNC, ERR_IO_PENDING, writes_.size() + reads_.size()));
+    provider_.reset(new SequencedSocketData(&reads_[0], reads_.size(),
+                                            &writes_[0], writes_.size()));
     if (use_tcp_) {
       provider_->set_connect_data(MockConnect(reads_[0].mode, OK));
     }
@@ -125,20 +126,16 @@ class DnsSocketData {
     return query_->id();
   }
 
-  // Returns true if the expected query was written to the socket.
-  bool was_written() const {
-    CHECK(provider_.get());
-    return provider_->write_index() > 0;
-  }
-
  private:
+  size_t num_reads_and_writes() const { return reads_.size() + writes_.size(); }
+
   scoped_ptr<DnsQuery> query_;
   bool use_tcp_;
   ScopedVector<uint16> lengths_;
   ScopedVector<DnsResponse> responses_;
   std::vector<MockWrite> writes_;
   std::vector<MockRead> reads_;
-  scoped_ptr<DelayedSocketData> provider_;
+  scoped_ptr<SequencedSocketData> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsSocketData);
 };
@@ -454,7 +451,7 @@ class DnsTransactionTest : public testing::Test {
   void TearDown() override {
     // Check that all socket data was at least written to.
     for (size_t i = 0; i < socket_data_.size(); ++i) {
-      EXPECT_TRUE(socket_data_[i]->was_written()) << i;
+      EXPECT_TRUE(socket_data_[i]->GetProvider()->AllWriteDataConsumed()) << i;

[mmenke, 2015/05/04 20:08:32]

No such method...

[Ryan Hamilton, 2015/05/04 20:12:33]

Pretty sure there is :>. I added it in this CL:

https://codereview.chromium.org/1114383003/

(Which I landed after our email exchange about needing a common base class for
Static and Sequenced socket data)

I verified that this version of the patch built after I rebased onto tip of
trunk

[mmenke, 2015/05/04 20:14:11]

Erm...this CL doesn't touch any header files....

[mmenke, 2015/05/04 20:15:02]

Oops, missed the link.  So used to ignoring links at the end of codereview
emails that I missed it.

     }
   }