Convert the remaining three SpdyNetworkTransactionTests to SequencedSocketData

net/socket/sequenced_socket_data_unittest.cc

 // Copyright 2015 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 <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 176 matching lines @@
                   size_t writes_count);
 
   void AssertSyncReadEquals(const char* data, int len);
   void AssertAsyncReadEquals(const char* data, int len);
   void AssertReadReturns(int len, int rv);
   void AssertReadBufferEquals(const char* data, int len);
 
   void AssertSyncWriteEquals(const char* data, int len);
   void AssertAsyncWriteEquals(const char* data, int len);
   void AssertWriteReturns(const char* data, int len, int rv);
+  void CompleteRead();
 
   // When a given test completes, data_.at_eof() is expected to
   // match the value specified here. Most test should consume all
   // reads and writes, but some tests verify error handling behavior
   // do not consume all data.
   void set_expect_eof(bool expect_eof) { expect_eof_ = expect_eof; }
 
   TestCompletionCallback read_callback_;
   scoped_refptr<IOBuffer> read_buf_;
   TestCompletionCallback write_callback_;
@@ skipping 99 matching lines @@
                                                      int len) {
   // Issue the read, which should be completed asynchronously.
   AssertWriteReturns(data, len, ERR_IO_PENDING);
 
   EXPECT_FALSE(read_callback_.have_result());
   EXPECT_TRUE(sock_->IsConnected());
 
   ASSERT_EQ(len, write_callback_.WaitForResult());
 }
 
+void SequencedSocketDataTest::CompleteRead() {
+  data_->CompleteRead();
+}
+
 void SequencedSocketDataTest::AssertWriteReturns(const char* data,
                                                  int len,
                                                  int rv) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
   memcpy(buf->data(), data, len);
 
   if (rv == ERR_IO_PENDING) {
     ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback()));
     ASSERT_FALSE(write_callback_.have_result());
   } else {
@@ skipping 270 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf.get(), 1, read_callback_.callback()));
   ASSERT_FALSE(read_callback_.have_result());
 
   // Even though the read is scheduled to complete at sequence number 0,
   // verify that the read callback in never called.
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_FALSE(read_callback_.have_result());
 }
 
+TEST_F(SequencedSocketDataTest, CompleteRead) {
+  MockRead reads[] = {
+      MockRead(ASYNC, ERR_IO_PENDING, 0), MockRead(ASYNC, kMsg1, kLen1, 1),
+  };
+
+  Initialize(reads, arraysize(reads), nullptr, 0);
+
+  AssertReadReturns(kLen1, ERR_IO_PENDING);
+  ASSERT_FALSE(read_callback_.have_result());
+
+  // Even though the read is scheduled to complete at sequence number 0,
+  // verify that the read callback in not called, until CompleteRead() is.
+  base::MessageLoop::current()->RunUntilIdle();
+  ASSERT_FALSE(read_callback_.have_result());
+
+  CompleteRead();
+
+  ASSERT_TRUE(read_callback_.have_result());
+  ASSERT_EQ(kLen1, read_callback_.WaitForResult());
+  AssertReadBufferEquals(kMsg1, kLen1);
+}
+
 // ----------- Write
 
 TEST_F(SequencedSocketDataTest, SingleSyncWriteTooEarly) {
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1),
   };
 
   MockRead reads[] = {MockRead(SYNCHRONOUS, 0, 0)};
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
@@ skipping 450 matching lines @@
 
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(helper.read_buf().get(), kLen1, helper.callback()));
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net