Implement server push protocol 2.

net/spdy/spdy_network_transaction_unittest.cc

 // 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 <vector>
 
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_network_transaction.h"
 #include "net/spdy/spdy_test_util.h"
+#include "net/url_request/url_request_unittest.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 // This is the expected list of advertised protocols from the browser's NPN
 // list.
 static const char kExpectedNPNString[] = "\x08http/1.1\x06spdy/2";
 
@@ skipping 54 matching lines @@
                 NOTREACHED();
             }
           }
 
     void RunPreTestSetup() {
       if (!session_deps_.get())
         session_deps_.reset(new SpdySessionDependencies());
       if (!session_.get())
         session_ = SpdySessionDependencies::SpdyCreateSession(
             session_deps_.get());
-
       HttpNetworkTransaction::SetUseAlternateProtocols(false);
       HttpNetworkTransaction::SetUseSSLOverSpdyWithoutNPN(false);
       HttpNetworkTransaction::SetUseSpdyWithoutNPN(false);
       switch (test_type_) {
         case SPDYNPN:
           session_->mutable_alternate_protocols()->SetAlternateProtocolFor(
               HostPortPair("www.google.com", 80), 443,
               HttpAlternateProtocols::NPN_SPDY_2);
           HttpNetworkTransaction::SetUseAlternateProtocols(true);
           HttpNetworkTransaction::SetNextProtos(kExpectedNPNString);
@@ skipping 77 matching lines @@
                                            << " Read index: "
                                            << (*it)->read_index();
         EXPECT_TRUE(!(*it)->at_write_eof()) << "Write count: "
                                             << (*it)->write_count()
                                             << " Write index: "
                                             << (*it)->write_index();
       }
     }
 
     void RunToCompletion(StaticSocketDataProvider* data) {
+      RunPreTestSetup();
       AddData(data);
-      RunPreTestSetup();
       RunDefaultTest();
       VerifyDataConsumed();
     }
 
     void AddData(StaticSocketDataProvider* data) {
       data_vector_.push_back(data);
       linked_ptr<SSLSocketDataProvider> ssl_(
           new SSLSocketDataProvider(true, OK));
       if (test_type_ == SPDYNPN) {
         ssl_->next_proto_status = SSLClientSocket::kNextProtoNegotiated;
@@ skipping 41 matching lines @@
     const BoundNetLog& log_;
     SpdyNetworkTransactionTestTypes test_type_;
     int port_;
   };
 
   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
                                              int expected_status);
 
   void ConnectStatusHelper(const MockRead& status);
 
+  const HttpRequestInfo& CreateGetPushRequest() {
+    google_get_push_request_.method = "GET";
+    google_get_push_request_.url = GURL("http://www.google.com/foo.dat");
+    google_get_push_request_.load_flags = 0;
+    return google_get_push_request_;
+  }
+
   const HttpRequestInfo& CreateGetRequest() {
     if (!google_get_request_initialized_) {
       google_get_request_.method = "GET";
       google_get_request_.url = GURL("http://www.google.com/");
       google_get_request_.load_flags = 0;
       google_get_request_initialized_ = true;
     }
     return google_get_request_;
   }
 
+  class RunServerPushTestCallback : public CallbackRunner< Tuple1<int> > {
+   public:
+    RunServerPushTestCallback(scoped_refptr<net::IOBufferWithSize> buffer,
+                              std::string& result, bool& need_read_callback)
+        : buffer_(buffer), result_(result),
+        need_read_callback_(need_read_callback) {}
+
+    virtual void RunWithParams(const Tuple1<int>& params) {
+      // Indicates some type of error.
+      if(params.a <= 0)
+        return;
+
+      std::string temp(buffer_->data(), params.a);
+      result_.append(temp);
+      need_read_callback_ = true;
+    }
+
+   private:
+    scoped_refptr<net::IOBufferWithSize> buffer_;
+    std::string& result_;
+    bool need_read_callback_;
+  };
+
+  void RunServerPushTest(MockWrite writes[], int writes_length,
+                         MockRead reads[], int reads_length,
+                         HttpResponseInfo* response,
+                         HttpResponseInfo* response2,
+                         std::string& expected) {
+    scoped_refptr<OrderedSocketData> data(
+        new OrderedSocketData(reads, reads_length,
+                              writes, writes_length));
+    NormalSpdyTransactionHelper helper(CreateGetRequest(),
+                                       BoundNetLog(), GetParam());
+
+    helper.RunPreTestSetup();
+    helper.AddData(data.get());
+
+    HttpNetworkTransaction* trans = helper.trans();
+
+    // Start the transaction with basic parameters.
+    TestCompletionCallback callback;
+    int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+    rv = callback.WaitForResult();
+
+    // Request the pushed path.
+    const int kSize = 3000;
+    scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kSize);
+    scoped_ptr<HttpNetworkTransaction> trans2(
+        new HttpNetworkTransaction(helper.session()));
+    rv = trans2->Start(&CreateGetPushRequest(), &callback, BoundNetLog());
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+    MessageLoop::current()->RunAllPending();
+
+    // The data for the pushed path may be coming in more than 1 packet. Compile
+    // the results into a single string.
+    std::string result;
+    bool need_read_callback = true;
+    RunServerPushTestCallback callback2(buf, result, need_read_callback);
+    while(!data->at_read_eof())
+    {
+      if(need_read_callback) {
+        while((rv = trans2->Read(buf, kSize, &callback2)) > 0) {
+          std::string result1(buf->data(),rv);
+          result.append(result1);
+        }
+        need_read_callback = false;
+      }
+      else
+        data->CompleteRead();
+      MessageLoop::current()->RunAllPending();
+    }
+
+    // Verify that we consumed all test data.
+    EXPECT_TRUE(data->at_read_eof());
+    EXPECT_TRUE(data->at_write_eof());
+
+    // Verify that the received push data is same as the expected push data.
+    EXPECT_EQ(result.compare(expected),0) << "Received data: "
+                                          << result
+                                          << "||||| Expected data: "
+                                          << expected;
+
+    // Verify the SYN_REPLY.
+    // Copy the response info, because trans goes away.
+    *response = *trans->GetResponseInfo();
+    *response2 = *trans2->GetResponseInfo();
+  }
+
  private:
   bool google_get_request_initialized_;
   HttpRequestInfo google_get_request_;
+  HttpRequestInfo google_get_push_request_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different connection types: SPDY after NPN
 // negotiation, SPDY without SSL, and SPDY with SSL.
 INSTANTIATE_TEST_CASE_P(SpdyNetworkingTest,
                         SpdyNetworkTransactionTest,
-                        ::testing::Values(SPDYNPN, SPDYNOSSL, SPDYSSL));
+                        ::testing::Values(SPDYNOSSL, SPDYSSL, SPDYNPN));
 
 
 // Verify HttpNetworkTransaction constructor.
 TEST_P(SpdyNetworkTransactionTest, Constructor) {
   SpdySessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session =
       SpdySessionDependencies::SpdyCreateSession(&session_deps);
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 }
 
@@ skipping 729 matching lines @@
     CreateMockRead(*resp.get(), 2),
     CreateMockRead(*body.get(), 3),
     MockRead(false, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(0, reads, arraysize(reads),
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(request,
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   helper.RunDefaultTest();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 // The client upon cancellation tries to send a RST_STREAM frame. The mock
 // socket causes the TCP write to return zero. This test checks that the client
 // tries to queue up the RST_STREAM frame again.
 TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
@@ skipping 61 matching lines @@
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 172 matching lines @@
     // HttpNetworkTransaction and still tries to continue Read()'ing.  Any
     // MockRead will do here.
     MockRead(true, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(&data);
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   helper.ResetTrans();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
@@ skipping 16 matching lines @@
     MockRead(true, 0, 0, 4)  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(),
                                      GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   helper.ResetTrans();  // Cancel the transaction.
 
   // Finish running rest of tasks.
@@ skipping 62 matching lines @@
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
   scoped_refptr<DelayedSocketData> data2(
       new DelayedSocketData(0, reads2, arraysize(reads2),
                             writes2, arraysize(writes2)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
   helper.AddData(data2.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   StartTransactionCallback callback2(helper.session(), helper);
   const int kSize = 3000;
@@ skipping 36 matching lines @@
     CreateMockRead(*body.get(), 4),
     MockRead(true, 0, 0, 5),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // Setup a user callback which will delete the session, and clear out the
   // memory holding the stream object. Note that the callback deletes trans.
   DeleteSessionCallback callback2(helper);
   const int kSize = 3000;
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
   rv = trans->Read(buf, kSize, &callback2);
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data->CompleteRead();
 
   // Finish running rest of tasks.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataConsumed();
 }
 
+// Send a spdy request to www.google.com that gets redirected to www.foo.com.
+TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) {
+  // These are headers which the URLRequest tacks on.
+  const char* const kExtraHeaders[] = {
+    "accept-charset",
+    "",
+    "accept-encoding",
+    "gzip,deflate",
+    "accept-language",
+    "",
+  };
+  const SpdyHeaderInfo kSynStartHeader = make_spdy_header(spdy::SYN_STREAM);
+  const char* const kStandardGetHeaders[] = {
+    "host",
+    "www.google.com",
+    "method",
+    "GET",
+    "scheme",
+    "http",
+    "url",
+    "/",
+    "user-agent",
+    "",
+    "version",
+    "HTTP/1.1"
+  };
+  const char* const kStandardGetHeaders2[] = {
+    "host",
+    "www.foo.com",
+    "method",
+    "GET",
+    "scheme",
+    "http",
+    "url",
+    "/index.php",
+    "user-agent",
+    "",
+    "version",
+    "HTTP/1.1"
+  };
+
+  // Setup writes/reads to www.google.com
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPacket(
+      kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders)/2,
+      kStandardGetHeaders, arraysize(kStandardGetHeaders)/2));
+  scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyPacket(
+      kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders)/2,
+      kStandardGetHeaders2, arraysize(kStandardGetHeaders2)/2));
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReplyRedirect(1));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+  };
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    MockRead(true, 0, 0, 3)  // EOF
+  };
+
+  // Setup writes/reads to www.foo.com
+  scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
+  MockWrite writes2[] = {
+    CreateMockWrite(*req2, 1),
+  };
+  MockRead reads2[] = {
+    CreateMockRead(*resp2, 2),
+    CreateMockRead(*body2, 3),
+    MockRead(true, 0, 0, 4)  // EOF
+  };
+  scoped_refptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads),
+                            writes, arraysize(writes)));
+  scoped_refptr<OrderedSocketData> data2(
+      new OrderedSocketData(reads2, arraysize(reads2),
+                            writes2, arraysize(writes2)));
+
+  // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
+  HttpNetworkTransaction::SetUseSSLOverSpdyWithoutNPN(false);
+  HttpNetworkTransaction::SetUseSpdyWithoutNPN(true);
+  TestDelegate d;
+  {
+    URLRequest r(GURL("http://www.google.com/"), &d);
+    SpdyURLRequestContext* spdy_url_request_context =
+        new SpdyURLRequestContext();
+    r.set_context(spdy_url_request_context);
+    spdy_url_request_context->socket_factory().
+        AddSocketDataProvider(data.get());
+    spdy_url_request_context->socket_factory().
+        AddSocketDataProvider(data2.get());
+
+    d.set_quit_on_redirect(true);
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.received_redirect_count());
+
+    r.FollowDeferredRedirect();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    std::string contents("hello!");
+    EXPECT_EQ(contents, d.data_received());
+  }
+  EXPECT_TRUE(data->at_read_eof());
+  EXPECT_TRUE(data->at_write_eof());
+  EXPECT_TRUE(data2->at_read_eof());
+  EXPECT_TRUE(data2->at_write_eof());
+}
+
+// Send a spdy request to www.google.com. Get a pushed stream that redirects to
+// www.foo.com.
+TEST_P(SpdyNetworkTransactionTest, RedirectServerPush) {
+  // These are headers which the URLRequest tacks on.
+  const char* const kExtraHeaders[] = {
+    "accept-charset",
+    "",
+    "accept-encoding",
+    "gzip,deflate",
+    "accept-language",
+    "",
+  };
+  const SpdyHeaderInfo kSynStartHeader = make_spdy_header(spdy::SYN_STREAM);
+  const char* const kStandardGetHeaders[] = {
+    "host",
+    "www.google.com",
+    "method",
+    "GET",
+    "scheme",
+    "http",
+    "url",
+    "/",
+    "user-agent",
+    "",
+    "version",
+    "HTTP/1.1"
+  };
+  const char* const kStandardGetHeaders2[] = {
+    "host",
+    "www.foo.com",
+    "method",
+    "GET",
+    "scheme",
+    "http",
+    "url",
+    "/index.php",
+    "user-agent",
+    "",
+    "version",
+    "HTTP/1.1"
+  };
+
+  // Setup writes/reads to www.google.com
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyPacket(
+      kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders)/2,
+      kStandardGetHeaders, arraysize(kStandardGetHeaders)/2));
+  scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyPacket(
+      kSynStartHeader, kExtraHeaders, arraysize(kExtraHeaders)/2,
+      kStandardGetHeaders2, arraysize(kStandardGetHeaders2)/2));
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 1, "/foo.dat",
+      "301 Moved Permanently", "http://www.foo.com/index.php",
+      "http://www.foo.com/index.php"));
+  scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<spdy::SpdyFrame> res(
+      ConstructSpdyRstStream(2, spdy::CANCEL));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+    CreateMockWrite(*res, 6),
+  };
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    CreateMockRead(*body, 4),
+    MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
+    MockRead(true, 0, 0, 7)  // EOF
+  };
+
+  // Setup writes/reads to www.foo.com
+  scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
+  MockWrite writes2[] = {
+    CreateMockWrite(*req2, 1),
+  };
+  MockRead reads2[] = {
+    CreateMockRead(*resp2, 2),
+    CreateMockRead(*body2, 3),
+    MockRead(true, 0, 0, 5)  // EOF
+  };
+  scoped_refptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads),
+                            writes, arraysize(writes)));
+  scoped_refptr<OrderedSocketData> data2(
+      new OrderedSocketData(reads2, arraysize(reads2),
+                            writes2, arraysize(writes2)));
+
+  // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
+  HttpNetworkTransaction::SetUseSSLOverSpdyWithoutNPN(false);
+  HttpNetworkTransaction::SetUseSpdyWithoutNPN(true);
+  TestDelegate d;
+  TestDelegate d2;
+  {
+    URLRequest r(GURL("http://www.google.com/"), &d);
+    SpdyURLRequestContext* spdy_url_request_context =
+        new SpdyURLRequestContext();
+    r.set_context(spdy_url_request_context);
+    spdy_url_request_context->socket_factory().
+        AddSocketDataProvider(data.get());
+
+    r.Start();
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(0, d.received_redirect_count());
+    std::string contents("hello!");
+    EXPECT_EQ(contents, d.data_received());
+
+    URLRequest r2(GURL("http://www.google.com/foo.dat"), &d2);
+    r2.set_context(spdy_url_request_context);
+    spdy_url_request_context->socket_factory().
+        AddSocketDataProvider(data2.get());
+
+    d2.set_quit_on_redirect(true);
+    r2.Start();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(1, d2.received_redirect_count());
+
+    r2.FollowDeferredRedirect();
+    MessageLoop::current()->Run();
+    EXPECT_EQ(1, d2.response_started_count());
+    EXPECT_FALSE(d2.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r2.status().status());
+    std::string contents2("hello!");
+    EXPECT_EQ(contents2, d2.data_received());
+  }
+  data->CompleteRead();
+  data2->CompleteRead();
+  EXPECT_TRUE(data->at_read_eof());
+  EXPECT_TRUE(data->at_write_eof());
+  EXPECT_TRUE(data2->at_read_eof());
+  EXPECT_TRUE(data2->at_write_eof());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
+  static const unsigned char kPushBodyFrame[] = {
+    0x00, 0x00, 0x00, 0x02,                                      // header, ID
+    0x01, 0x00, 0x00, 0x05,                                      // FIN, length
+    'h', 'e', 'l', 'l', 'o',                                     // "hello"
+  };
+
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 1, "/foo.dat"));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame),
+             arraysize(kPushBodyFrame), 4),
+    MockRead(true, ERR_IO_PENDING, 5),  // Force a pause
+    MockRead(true, 0, 0, 6)  // EOF
+  };
+
+  HttpResponseInfo response;
+  HttpResponseInfo response2;
+  std::string expected_push_result("hello");
+  RunServerPushTest(writes, arraysize(writes), reads, arraysize(reads),
+                    &response, &response2, expected_push_result);
+
+  // Verify the SYN_REPLY.
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+
+  // Verify the pushed stream.
+  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) {
+  static const unsigned char kPushBodyFrame1[] = {
+    0x00, 0x00, 0x00, 0x02,                                      // header, ID
+    0x01, 0x00, 0x00, 0x1E,                                      // FIN, length
+    'h', 'e', 'l', 'l', 'o',                                     // "hello"
+  };
+  static const char kPushBodyFrame2[] = " my darling";
+  static const char kPushBodyFrame3[] = " hello";
+  static const char kPushBodyFrame4[] = " my baby";
+
+  scoped_ptr<spdy::SpdyFrame> req(
+      ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 1, "/foo.dat"));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame1),
+             arraysize(kPushBodyFrame1), 4),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame2),
+             arraysize(kPushBodyFrame2) - 1, 5),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame3),
+             arraysize(kPushBodyFrame3) - 1, 6),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
+             arraysize(kPushBodyFrame4) - 1, 7),
+    MockRead(true, ERR_IO_PENDING, 8),  // Force a pause
+    MockRead(true, 0, 0, 9)  // EOF
+  };
+
+  HttpResponseInfo response;
+  HttpResponseInfo response2;
+  std::string expected_push_result("hello my darling hello my baby");
+  RunServerPushTest(writes, arraysize(writes), reads, arraysize(reads),
+                    &response, &response2, expected_push_result);
+
+  // Verify the SYN_REPLY.
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+
+  // Verify the pushed stream.
+  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
+  static const unsigned char kPushBodyFrame1[] = {
+    0x00, 0x00, 0x00, 0x02,                                      // header, ID
+    0x01, 0x00, 0x00, 0x1E,                                      // FIN, length
+    'h', 'e', 'l', 'l', 'o',                                     // "hello"
+  };
+  static const char kPushBodyFrame2[] = " my darling";
+  static const char kPushBodyFrame3[] = " hello";
+  static const char kPushBodyFrame4[] = " my baby";
+
+  scoped_ptr<spdy::SpdyFrame> req(
+      ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 1, "/foo.dat"));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame1),
+             arraysize(kPushBodyFrame1), 4),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame2),
+             arraysize(kPushBodyFrame2) - 1, 5),
+    MockRead(true, ERR_IO_PENDING, 6),  // Force a pause
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame3),
+             arraysize(kPushBodyFrame3) - 1, 7),
+    MockRead(true, reinterpret_cast<const char*>(kPushBodyFrame4),
+             arraysize(kPushBodyFrame4) - 1, 8),
+    MockRead(true, 0, 0, 9)  // EOF
+  };
+
+  HttpResponseInfo response;
+  HttpResponseInfo response2;
+  std::string expected_push_result("hello my darling hello my baby");
+  RunServerPushTest(writes, arraysize(writes), reads, arraysize(reads),
+                    &response, &response2, expected_push_result);
+
+  // Verify the SYN_REPLY.
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+
+  // Verify the pushed stream.
+  EXPECT_TRUE(response2.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  scoped_ptr<spdy::SpdyFrame> res(
+      ConstructSpdyRstStream(2, spdy::INVALID_STREAM));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+    CreateMockWrite(*res, 4),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 0, "/foo.dat"));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, 0, 0, 5)  // EOF
+  };
+
+  scoped_refptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads),
+                            writes, arraysize(writes)));
+  NormalSpdyTransactionHelper helper(CreateGetRequest(),
+                                     BoundNetLog(), GetParam());
+
+  helper.RunPreTestSetup();
+  helper.AddData(data.get());
+
+  HttpNetworkTransaction* trans = helper.trans();
+
+  // Start the transaction with basic parameters.
+  TestCompletionCallback callback;
+  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = callback.WaitForResult();
+  data->CompleteRead();
+  EXPECT_EQ(OK, rv);
+
+  // Verify that we consumed all test data.
+  EXPECT_TRUE(data->at_read_eof()) << "Read count: "
+                                   << data->read_count()
+                                   << " Read index: "
+                                   << data->read_index();
+  EXPECT_TRUE(data->at_write_eof()) << "Write count: "
+                                    << data->write_count()
+                                    << " Write index: "
+                                    << data->write_index();
+
+  // Verify the SYN_REPLY.
+  HttpResponseInfo response = *trans->GetResponseInfo();
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) {
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  scoped_ptr<spdy::SpdyFrame> res(
+      ConstructSpdyRstStream(2, spdy::INVALID_ASSOCIATED_STREAM));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+    CreateMockWrite(*res, 4),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 9, "/foo.dat"));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, 0, 0, 5)  // EOF
+  };
+
+  scoped_refptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads),
+                            writes, arraysize(writes)));
+  NormalSpdyTransactionHelper helper(CreateGetRequest(),
+                                     BoundNetLog(), GetParam());
+
+  helper.RunPreTestSetup();
+  helper.AddData(data.get());
+
+  HttpNetworkTransaction* trans = helper.trans();
+
+  // Start the transaction with basic parameters.
+  TestCompletionCallback callback;
+  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = callback.WaitForResult();
+  data->CompleteRead();
+  EXPECT_EQ(OK, rv);
+
+  // Verify that we consumed all test data.
+  EXPECT_TRUE(data->at_read_eof()) << "Read count: "
+                                   << data->read_count()
+                                   << " Read index: "
+                                   << data->read_index();
+  EXPECT_TRUE(data->at_write_eof()) << "Write count: "
+                                    << data->write_count()
+                                    << " Write index: "
+                                    << data->write_index();
+
+  // Verify the SYN_REPLY.
+  HttpResponseInfo response = *trans->GetResponseInfo();
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+}
+
+TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) {
+  scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
+  scoped_ptr<spdy::SpdyFrame> res(
+      ConstructSpdyRstStream(2, spdy::PROTOCOL_ERROR));
+  MockWrite writes[] = {
+    CreateMockWrite(*req, 1),
+    CreateMockWrite(*res, 4),
+  };
+
+  scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<spdy::SpdyFrame> rep(ConstructSpdyPush(NULL, 0, 2, 1));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*rep, 3),
+    MockRead(true, 0, 0, 5)  // EOF
+  };
+
+  scoped_refptr<OrderedSocketData> data(
+      new OrderedSocketData(reads, arraysize(reads),
+                            writes, arraysize(writes)));
+  NormalSpdyTransactionHelper helper(CreateGetRequest(),
+                                     BoundNetLog(), GetParam());
+
+  helper.RunPreTestSetup();
+  helper.AddData(data.get());
+
+  HttpNetworkTransaction* trans = helper.trans();
+
+  // Start the transaction with basic parameters.
+  TestCompletionCallback callback;
+  int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  rv = callback.WaitForResult();
+  data->CompleteRead();
+  EXPECT_EQ(OK, rv);
+  // Verify that we consumed all test data.
+  EXPECT_TRUE(data->at_read_eof()) << "Read count: "
+                                   << data->read_count()
+                                   << " Read index: "
+                                   << data->read_index();
+  EXPECT_TRUE(data->at_write_eof()) << "Write count: "
+                                    << data->write_count()
+                                    << " Write index: "
+                                    << data->write_index();
+
+  // Verify the SYN_REPLY.
+  HttpResponseInfo response = *trans->GetResponseInfo();
+  EXPECT_TRUE(response.headers != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
+}
+
 // Verify that various SynReply headers parse correctly through the
 // HTTP layer.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) {
   struct SynReplyHeadersTests {
     int num_headers;
     const char* extra_headers[5];
     const char* expected_headers;
   } test_cases[] = {
     // This uses a multi-valued cookie header.
     { 2,
@@ skipping 525 matching lines @@
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
 
   TestCompletionCallback callback;
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
@@ skipping 57 matching lines @@
       CreateMockRead(*resp),
       CreateMockRead(*body),
       MockRead(true, 0, 0)  // EOF
     };
 
     scoped_refptr<DelayedSocketData> data(
         new DelayedSocketData(connects[index], 1, reads, arraysize(reads),
                               writes, arraysize(writes)));
     NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                        BoundNetLog(), GetParam());
+    helper.RunPreTestSetup();
     helper.AddData(data.get());
-    helper.RunPreTestSetup();
 
     // Set up http fallback data.
     MockRead http_fallback_data[] = {
       MockRead("HTTP/1.1 200 OK\r\n\r\n"),
       MockRead("hello world!!!"),
       MockRead(true, OK),
     };
 
     scoped_ptr<StaticSocketDataProvider> http_fallback(
           new StaticSocketDataProvider(http_fallback_data,
@@ skipping 62 matching lines @@
     MockRead(true, combined_data_frames, combined_data_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
@@ skipping 73 matching lines @@
     MockRead(true, combined_frames, combined_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
@@ skipping 66 matching lines @@
     MockRead(true, combined_data_frames, combined_data_frames_len),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
@@ skipping 58 matching lines @@
     CreateMockRead(*data_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
   TestCompletionCallback callback;
 
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TransactionHelperResult out = helper.output();
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
@@ skipping 46 matching lines @@
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
   };
   static const char* const kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
   };
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   EXPECT_TRUE(helper.session()->spdy_settings().Get(host_port_pair).empty());
 
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   // Construct the reply.
@@ skipping 34 matching lines @@
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     CreateMockRead(*settings_frame),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
-  helper.RunToCompletion(data.get());
+  helper.AddData(data.get());
+  helper.RunDefaultTest();
+  helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     spdy::SpdySettings saved_settings =
         helper.session()->spdy_settings().Get(host_port_pair);
     ASSERT_EQ(2u, saved_settings.size());
@@ skipping 30 matching lines @@
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
   };
   static const char* kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
   };
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+  helper.RunPreTestSetup();
 
   // Verify that no settings exist initially.
   HostPortPair host_port_pair("www.google.com", helper.port());
   EXPECT_TRUE(helper.session()->spdy_settings().Get(host_port_pair).empty());
 
   unsigned int kSampleId1 = 0x1;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   unsigned int kSampleId2 = 0xababab;
   unsigned int kSampleValue2 = 0x0c0c0c0c;
   // Manually insert settings into the SpdySettingsStorage here.
@@ skipping 38 matching lines @@
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
     CreateMockRead(*reply),
     CreateMockRead(*body),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
-  helper.RunToCompletion(data.get());
+  helper.AddData(data.get());
+  helper.RunDefaultTest();
+  helper.VerifyDataConsumed();
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     spdy::SpdySettings saved_settings =
         helper.session()->spdy_settings().Get(host_port_pair);
     ASSERT_EQ(2u, saved_settings.size());
@@ skipping 90 matching lines @@
     CreateMockRead(*resp),
     MockRead(false, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   BoundNetLog log;
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      log, GetParam());
+  helper.RunPreTestSetup();
   helper.AddData(data.get());
-  helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   TransactionHelperResult out;
   out.rv = trans->Start(&CreateGetRequest(), &callback, log);
 
   EXPECT_EQ(out.rv, ERR_IO_PENDING);
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
@@ skipping 339 matching lines @@
       rv = ReadTransaction(trans.get(), &response_data);
       EXPECT_EQ(OK, rv);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
     }
 
     helper.VerifyDataConsumed();
   }
 }
 }  // namespace net