[SPDY] Enable tests for SPDY/3.1 and SPDY/4

net/spdy/spdy_session_unittest.cc

 // 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 "net/spdy/spdy_session.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 201 matching lines @@
   GURL test_url_;
   HostPortPair test_host_port_pair_;
   SpdySessionKey key_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     SpdySessionTest,
     testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
 
-// TODO(akalin): Don't early-exit in the tests below for values >
-// kProtoSPDY3.
-
 TEST_P(SpdySessionTest, GoAway) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
   MockRead reads[] = {
     CreateMockRead(*goaway, 2),
     MockRead(ASYNC, 0, 3)  // EOF
   };
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
@@ skipping 62 matching lines @@
   // Delete the first session.
   session = NULL;
 
   // Delete the second session.
   spdy_session_pool_->Remove(session2);
   session2 = NULL;
   EXPECT_EQ(NULL, spdy_stream2.get());
 }
 
 TEST_P(SpdySessionTest, ClientPing) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.enable_ping = true;
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(1));
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1));
@@ skipping 36 matching lines @@
   EXPECT_FALSE(session->check_ping_status_pending());
   EXPECT_GE(session->last_activity_time(), before_ping_time);
 
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   // Delete the first session.
   session = NULL;
 }
 
 TEST_P(SpdySessionTest, ServerPing) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(2));
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(2));
   MockWrite writes[] = {
@@ skipping 22 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   // Delete the session.
   session = NULL;
   EXPECT_EQ(NULL, spdy_stream1.get());
 }
 
 TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   session_deps_.time_func = TheNearFuture;
 
   CreateNetworkSession();
 
   scoped_refptr<SpdySession> session = GetSession(key_);
 
@@ skipping 36 matching lines @@
   // Verify that the second pushed stream evicted the first pushed stream.
   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
   iter = session->unclaimed_pushed_streams_.find("http://www.google.com/b.dat");
   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
 
   // Delete the session.
   session = NULL;
 }
 
 TEST_P(SpdySessionTest, FailedPing) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(1));
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1));
   MockWrite writes[] = {
@@ skipping 42 matching lines @@
   EXPECT_EQ(0u, session->num_active_streams());
   EXPECT_EQ(0u, session->num_unclaimed_pushed_streams());
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   // Delete the first session.
   session = NULL;
   EXPECT_EQ(NULL, spdy_stream1.get());
 }
 
 TEST_P(SpdySessionTest, CloseIdleSessions) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   CreateNetworkSession();
@@ skipping 103 matching lines @@
   EXPECT_FALSE(session2->is_active());
   EXPECT_TRUE(session2->IsClosed());
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  Receive a
 // settings frame setting max concurrent streams to 2.  Have the callback
 // release the stream, which releases its reference (the last) to the session.
 // Make sure nothing blows up.
 // http://crbug.com/57331
 TEST_P(SpdySessionTest, OnSettings) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   SettingsMap new_settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   const uint32 max_concurrent_streams = 2;
   new_settings[kSpdySettingsIds1] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
 
   // Set up the socket so we read a SETTINGS frame that raises max concurrent
   // streams to 2.
@@ skipping 38 matching lines @@
                 stream_releaser.MakeCallback(&request)));
   session = NULL;
 
   EXPECT_EQ(OK, stream_releaser.WaitForResult());
 }
 
 // Start with max concurrent streams set to 1 (that is persisted). Receive a
 // settings frame setting max concurrent streams to 2 and which also clears the
 // persisted data. Verify that persisted data is correct.
 TEST_P(SpdySessionTest, ClearSettings) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   SettingsMap new_settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   const uint32 max_concurrent_streams = 2;
   new_settings[kSpdySettingsIds1] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
 
   // Set up the socket so we read a SETTINGS frame that raises max concurrent
   // streams to 2 and clears previously persisted data.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(new_settings));
   uint8 flags = SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
-  test::SetFrameFlags(settings_frame.get(), flags, SPDY3);
+  test::SetFrameFlags(settings_frame.get(), flags, spdy_util_.spdy_version());
   MockRead reads[] = {
     CreateMockRead(*settings_frame),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
@@ skipping 38 matching lines @@
   EXPECT_EQ(2u, session->max_concurrent_streams());
 
   session = NULL;
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  When the
 // first completes, have the callback close itself, which should trigger the
 // second stream creation.  Then cancel that one immediately.  Don't crash.
 // http://crbug.com/63532
 TEST_P(SpdySessionTest, CancelPendingCreateStream) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   data.set_connect_data(connect_data);
@@ skipping 35 matching lines @@
   EXPECT_EQ(NULL, spdy_stream1.get());
 
   request.CancelRequest();
   callback.reset();
 
   // Should not crash when running the pending callback.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_P(SpdySessionTest, SendInitialSettingsOnNewSession) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   SettingsMap settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   const SpdySettingsIds kSpdySettingsIds2 = SETTINGS_INITIAL_WINDOW_SIZE;
   const uint32 kInitialRecvWindowSize = 10 * 1024 * 1024;
   settings[kSpdySettingsIds1] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
   if (spdy_util_.spdy_version() >= SPDY3) {
     settings[kSpdySettingsIds2] =
         SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kInitialRecvWindowSize);
   }
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
+  scoped_ptr<SpdyFrame> initial_window_update(
+      spdy_util_.ConstructSpdyWindowUpdate(
+          kSessionFlowControlStreamId,
+          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
+    CreateMockWrite(*initial_window_update),
   };
   session_deps_.stream_initial_recv_window_size = kInitialRecvWindowSize;
+  int num_writes = arraysize(writes);
+  // We don't have session windows for SPDY versions less than 3.1.
+  if (spdy_util_.protocol() < kProtoSPDY31) {
+    --num_writes;
+  }
 
-  StaticSocketDataProvider data(
-      reads, arraysize(reads), writes, arraysize(writes));
+  StaticSocketDataProvider data(reads, arraysize(reads), writes, num_writes);
   data.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   SpdySessionPoolPeer pool_peer(spdy_session_pool_);
   pool_peer.EnableSendingInitialSettings(true);
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdySessionTest, SendSettingsOnNewSession) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   // Create the bogus setting that we want to verify is sent out.
   // Note that it will be marked as SETTINGS_FLAG_PERSISTED when sent out. But
   // to persist it into the HttpServerProperties, we need to mark as
   // SETTINGS_FLAG_PLEASE_PERSIST.
@@ skipping 277 matching lines @@
 
 TEST_P(SpdySessionTest, IPPoolingCloseCurrentSessions) {
   IPPoolingTest(GetParam(), SPDY_POOL_CLOSE_CURRENT_SESSIONS);
 }
 
 TEST_P(SpdySessionTest, IPPoolingCloseIdleSessions) {
   IPPoolingTest(GetParam(), SPDY_POOL_CLOSE_IDLE_SESSIONS);
 }
 
 TEST_P(SpdySessionTest, ClearSettingsStorageOnIPAddressChanged) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   CreateNetworkSession();
 
   HttpServerProperties* test_http_server_properties =
       spdy_session_pool_->http_server_properties();
   SettingsFlagsAndValue flags_and_value1(SETTINGS_FLAG_PLEASE_PERSIST, 2);
   test_http_server_properties->SetSpdySetting(
       test_host_port_pair_,
       SETTINGS_MAX_CONCURRENT_STREAMS,
       SETTINGS_FLAG_PLEASE_PERSIST,
       2);
   EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair_).size());
   spdy_session_pool_->OnIPAddressChanged();
   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair_).size());
 }
 
 TEST_P(SpdySessionTest, Initialize) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 29 matching lines @@
 
   CapturingNetLog::CapturedEntry entry = entries[pos];
   NetLog::Source socket_source;
   EXPECT_TRUE(NetLog::Source::FromEventParameters(entry.params.get(),
                                                   &socket_source));
   EXPECT_TRUE(socket_source.IsValid());
   EXPECT_NE(log.bound().source().id, socket_source.id);
 }
 
 TEST_P(SpdySessionTest, CloseSessionOnError) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*goaway),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 33 matching lines @@
   CapturingNetLog::CapturedEntry entry = entries[pos];
   int error_code = 0;
   ASSERT_TRUE(entry.GetNetErrorCode(&error_code));
   EXPECT_EQ(ERR_CONNECTION_CLOSED, error_code);
 }
 
 // Queue up a low-priority SYN_STREAM followed by a high-priority
 // one. The high priority one should still send first and receive
 // first.
 TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // Construct the request.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> req_highest(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, HIGHEST, true));
   scoped_ptr<SpdyFrame> req_lowest(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req_highest, 0),
     CreateMockWrite(*req_lowest, 1),
   };
@@ skipping 62 matching lines @@
 
   data.RunFor(7);
 
   EXPECT_FALSE(spdy_stream_lowest);
   EXPECT_FALSE(spdy_stream_highest);
   EXPECT_EQ(3u, delegate_lowest.stream_id());
   EXPECT_EQ(1u, delegate_highest.stream_id());
 }
 
 TEST_P(SpdySessionTest, CancelStream) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   // Request 1, at HIGHEST priority, will be cancelled before it writes data.
   // Request 2, at LOWEST priority, will be a full request and will be id 1.
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req2, 0),
   };
 
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 59 matching lines @@
   EXPECT_EQ(1u, delegate2.stream_id());
 
   spdy_stream2->Cancel();
   EXPECT_EQ(NULL, spdy_stream2.get());
 }
 
 // Create two streams that are set to re-close themselves on close,
 // and then close the session. Nothing should blow up. Also a
 // regression test for http://crbug.com/139518 .
 TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   // No actual data will be sent.
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, 1)  // EOF
   };
 
   MockRead reads[] = {
@@ skipping 53 matching lines @@
 
   EXPECT_TRUE(delegate1.StreamIsClosed());
   EXPECT_TRUE(delegate2.StreamIsClosed());
 
   session = NULL;
 }
 
 // Create two streams that are set to close each other on close, and
 // then close the session. Nothing should blow up.
 TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   // No actual data will be sent.
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, 1)  // EOF
   };
 
   MockRead reads[] = {
@@ skipping 55 matching lines @@
 
   EXPECT_TRUE(delegate1.StreamIsClosed());
   EXPECT_TRUE(delegate2.StreamIsClosed());
 
   session = NULL;
 }
 
 // Create two streams that are set to re-close themselves on close,
 // activate them, and then close the session. Nothing should blow up.
 TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
@@ skipping 63 matching lines @@
 
   EXPECT_TRUE(delegate1.StreamIsClosed());
   EXPECT_TRUE(delegate2.StreamIsClosed());
 
   session = NULL;
 }
 
 // Create two streams that are set to close each other on close,
 // activate them, and then close the session. Nothing should blow up.
 TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
@@ skipping 63 matching lines @@
   EXPECT_EQ(NULL, spdy_stream1.get());
   EXPECT_EQ(NULL, spdy_stream2.get());
 
   EXPECT_TRUE(delegate1.StreamIsClosed());
   EXPECT_TRUE(delegate2.StreamIsClosed());
 
   session = NULL;
 }
 
 TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   // No actual data will be sent.
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, 1)  // EOF
   };
 
   MockRead reads[] = {
@@ skipping 48 matching lines @@
                                  BoundNetLog()));
 
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
   EXPECT_TRUE(session->VerifyDomainAuthentication("www.example.org"));
   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.org"));
   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.com"));
   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.google.com"));
 }
 
 TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   // No actual data will be sent.
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, 1)  // EOF
   };
 
   MockRead reads[] = {
@@ skipping 49 matching lines @@
                                  BoundNetLog()));
 
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
   EXPECT_TRUE(session->VerifyDomainAuthentication("www.example.org"));
   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.org"));
   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.example.com"));
   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.google.com"));
 }
 
 TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // TODO(rtenneti): Define a helper class/methods and move the common code in
   // this file.
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   SettingsMap new_settings;
   const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   const uint32 max_concurrent_streams = 1;
   new_settings[kSpdySettingsIds1] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
 
@@ skipping 118 matching lines @@
 
   EXPECT_EQ(0u, delegate3.stream_id());
   data.RunFor(4);
   EXPECT_EQ(NULL, stream3.get());
   EXPECT_EQ(5u, delegate3.stream_id());
   EXPECT_EQ(0u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(0u, session->pending_create_stream_queues(LOWEST));
 }
 
 TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   data.set_connect_data(connect_data);
@@ skipping 57 matching lines @@
 
   // Cancel the third stream.
   base::WeakPtr<SpdyStream> spdy_stream3 = request3.ReleaseStream();
   spdy_stream3->Cancel();
   EXPECT_EQ(NULL, spdy_stream3.get());
   EXPECT_EQ(0u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(0u, session->pending_create_stream_queues(LOWEST));
 }
 
 TEST_P(SpdySessionTest, NeedsCredentials) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   ssl.channel_id_sent = true;
@@ skipping 39 matching lines @@
 
   EXPECT_EQ(spdy_util_.spdy_version() >= SPDY3, session->NeedsCredentials());
 
   // Flush the SpdySession::OnReadComplete() task.
   base::MessageLoop::current()->RunUntilIdle();
 
   spdy_session_pool_->Remove(session);
 }
 
 TEST_P(SpdySessionTest, SendCredentials) {
-  if (GetParam() > kProtoSPDY3)
+  if (GetParam() < kProtoSPDY3)
     return;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   SettingsMap settings;
   scoped_ptr<SpdyFrame> settings_frame(
       spdy_util_.ConstructSpdySettings(settings));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
   };
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   ssl.channel_id_sent = true;
-  ssl.protocol_negotiated = kProtoSPDY3;
+  ssl.protocol_negotiated = GetParam();
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   const GURL kTestUrl("https://www.foo.com");
   HostPortPair test_host_port_pair(kTestUrl.host(), 443);
   SpdySessionKey key(test_host_port_pair, ProxyServer::Direct(),
                      kPrivacyModeDisabled);
 
   scoped_refptr<SpdySession> session = GetSession(key);
@@ skipping 28 matching lines @@
   EXPECT_TRUE(session->NeedsCredentials());
 
   // Flush the SpdySession::OnReadComplete() task.
   base::MessageLoop::current()->RunUntilIdle();
 
   spdy_session_pool_->Remove(session);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key));
 }
 
 TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
-  if (GetParam() != kProtoSPDY3)
+  if (GetParam() < kProtoSPDY3)
     return;
 
   // Set SETTINGS_INITIAL_WINDOW_SIZE to a small number so that WINDOW_UPDATE
   // gets sent.
   SettingsMap new_settings;
   int32 window_size = 1;
   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, window_size);
 
   // Set up the socket so we read a SETTINGS frame that sets
@@ skipping 41 matching lines @@
   ASSERT_TRUE(spdy_stream2.get() != NULL);
   EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
   spdy_stream2->Cancel();
   EXPECT_EQ(NULL, spdy_stream2.get());
 }
 
 // Test that SpdySession::DoRead reads data from the socket without yielding.
 // This test makes 32k - 1 bytes of data available on the socket for reading. It
 // then verifies that it has read all the available data without yielding.
 TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
   };
 
   // Build buffer of size kMaxReadBytes / 4 (-spdy_data_frame_size).
@@ skipping 69 matching lines @@
   EXPECT_EQ(0u, observer.executed_count());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data.at_read_eof());
 }
 
 // Test that SpdySession::DoRead yields while reading the data. This test makes
 // 32k + 1 bytes of data available on the socket for reading. It then verifies
 // that DoRead has yielded even though there is data available for it to read
 // (i.e, socket()->Read didn't return ERR_IO_PENDING during socket reads).
 TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
   };
 
   // Build buffer of size kMaxReadBytes / 4 (-spdy_data_frame_size).
@@ skipping 77 matching lines @@
 //
 // MockRead of SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 2K
 // ASYNC 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 8K, SYNCHRONOUS 2K.
 //
 // The above reads 26K synchronously. Since that is less that 32K, we will
 // attempt to read again. However, that DoRead() will return ERR_IO_PENDING
 // (because of async read), so DoRead() will yield. When we come back, DoRead()
 // will read the results from the async read, and rest of the data
 // synchronously.
 TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
   };
 
   // Build buffer of size kMaxReadBytes / 4 (-spdy_data_frame_size).
@@ skipping 85 matching lines @@
   EXPECT_EQ(1u, observer.executed_count());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data.at_read_eof());
 }
 
 // Send a GoAway frame when SpdySession is in DoLoop. If scoped_refptr to
 // <SpdySession> is deleted from SpdySession::DoLoop(), we get a crash because
 // GoAway could delete the SpdySession from the SpdySessionPool and the last
 // reference to SpdySession.
 TEST_P(SpdySessionTest, GoAwayWhileInDoLoop) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   MockConnect connect_data(SYNCHRONOUS, OK);
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 0),
   };
 
   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 87 matching lines @@
     EXPECT_EQ(0, session->session_recv_window_size_);
   } else if (GetParam() == kProtoSPDY3) {
     EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM, session->flow_control_state());
     EXPECT_EQ(0, session->session_send_window_size_);
     EXPECT_EQ(0, session->session_recv_window_size_);
   } else {
     EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
               session->flow_control_state());
     EXPECT_EQ(kSpdySessionInitialWindowSize,
               session->session_send_window_size_);
-    EXPECT_EQ(kDefaultInitialRecvWindowSize,
+    EXPECT_EQ(kSpdySessionInitialWindowSize,
               session->session_recv_window_size_);
   }
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 }
 
 // SpdySession::{Increase,Decrease}RecvWindowSize should properly
-// adjust the session receive window size when the "enable_spdy_31"
-// flag is set. In addition, SpdySession::IncreaseRecvWindowSize
-// should trigger sending a WINDOW_UPDATE frame for a large enough
-// delta.
+// adjust the session receive window size for SPDY 3.1 and higher. In
+// addition, SpdySession::IncreaseRecvWindowSize should trigger
+// sending a WINDOW_UPDATE frame for a large enough delta.
 TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   const int32 delta_window_size = 100;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
-    MockRead(ASYNC, 0, 2)  // EOF
+    MockRead(ASYNC, 0, 1)  // EOF
   };
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId,
           kSpdySessionInitialWindowSize + delta_window_size));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*window_update, 1),
+    CreateMockWrite(*window_update, 0),
   };
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
   scoped_refptr<SpdySession> session = GetSession(key_);
   InitializeSession(
       http_session_.get(), session.get(), test_host_port_pair_);
   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
             session->flow_control_state());
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   session->IncreaseRecvWindowSize(delta_window_size);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize + delta_window_size,
+  EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size,
             session->session_recv_window_size_);
   EXPECT_EQ(delta_window_size, session->session_unacked_recv_window_bytes_);
 
   // Should trigger sending a WINDOW_UPDATE frame.
   session->IncreaseRecvWindowSize(kSpdySessionInitialWindowSize);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize + delta_window_size +
+  EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size +
             kSpdySessionInitialWindowSize,
             session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
-  data.RunFor(2);
+  data.RunFor(1);
 
   session->DecreaseRecvWindowSize(
-      kDefaultInitialRecvWindowSize + delta_window_size +
+      kSpdySessionInitialWindowSize + delta_window_size +
       kSpdySessionInitialWindowSize);
   EXPECT_EQ(0, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 }
 
 // SpdySession::{Increase,Decrease}SendWindowSize should properly
 // adjust the session send window size when the "enable_spdy_31" flag
 // is set.
 TEST_P(SpdySessionTest, AdjustSendWindowSize) {
   if (GetParam() < kProtoSPDY31)
@@ skipping 32 matching lines @@
 // receive window size to decrease.
 TEST_P(SpdySessionTest, SessionFlowControlInactiveStream) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame(1, false));
   MockRead reads[] = {
-    CreateMockRead(*resp, 1),
-    MockRead(ASYNC, 0, 2)  // EOF
+    CreateMockRead(*resp, 0),
+    MockRead(ASYNC, 0, 1)  // EOF
   };
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-  };
-  DeterministicSocketData data(reads, arraysize(reads),
-                               writes, arraysize(writes));
+  DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
   scoped_refptr<SpdySession> session = GetSession(key_);
   InitializeSession(
       http_session_.get(), session.get(), test_host_port_pair_);
   EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
             session->flow_control_state());
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
-  data.RunFor(3);
+  data.RunFor(2);
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 }
 
 // A delegate that drops any received data.
 class DropReceivedDataDelegate : public test::StreamDelegateSendImmediate {
  public:
   DropReceivedDataDelegate(const base::WeakPtr<SpdyStream>& stream,
                            base::StringPiece data)
       : StreamDelegateSendImmediate(stream, data) {}
 
@@ skipping 10 matching lines @@
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
 
   const int32 msg_data_size = 100;
   const std::string msg_data(msg_data_size, 'a');
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   scoped_ptr<SpdyFrame> msg(
       spdy_util_.ConstructSpdyBodyFrame(
           1, msg_data.data(), msg_data_size, false));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req, 1),
-    CreateMockWrite(*msg, 3),
+    CreateMockWrite(*req, 0),
+    CreateMockWrite(*msg, 2),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> echo(
       spdy_util_.ConstructSpdyBodyFrame(
           1, msg_data.data(), msg_data_size, false));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId, msg_data_size));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    CreateMockRead(*echo, 4),
-    MockRead(ASYNC, 0, 5)  // EOF
+    CreateMockRead(*resp, 1),
+    CreateMockRead(*echo, 3),
+    MockRead(ASYNC, 0, 4)  // EOF
   };
 
   // Create SpdySession and SpdyStream and send the request.
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
@@ skipping 12 matching lines @@
 
   DropReceivedDataDelegate delegate(stream, msg_data);
   stream->SetDelegate(&delegate);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
-  data.RunFor(5);
+  data.RunFor(4);
 
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data.at_read_eof());
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 
   stream->Close();
   EXPECT_EQ(NULL, stream.get());
 
   EXPECT_EQ(OK, delegate.WaitForClose());
 
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 }
 
 // Send data back and forth but close the stream before its data frame
 // can be written to the socket. The send window should then increase
 // to its original value, i.e. we shouldn't "leak" send window bytes.
 TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
 
   const int32 msg_data_size = 100;
   const std::string msg_data(msg_data_size, 'a');
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req, 1),
+    CreateMockWrite(*req, 0),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    MockRead(ASYNC, 0, 3)  // EOF
+    CreateMockRead(*resp, 1),
+    MockRead(ASYNC, 0, 2)  // EOF
   };
 
   // Create SpdySession and SpdyStream and send the request.
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
@@ skipping 14 matching lines @@
   stream->SetDelegate(&delegate);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
 
-  data.RunFor(2);
+  data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
 
   data.RunFor(1);
 
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data.at_read_eof());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_send_window_size_);
@@ skipping 13 matching lines @@
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
 
   const int32 msg_data_size = 100;
   const std::string msg_data(msg_data_size, 'a');
 
   MockConnect connect_data(SYNCHRONOUS, OK);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
   scoped_ptr<SpdyFrame> msg(
       spdy_util_.ConstructSpdyBodyFrame(
           1, msg_data.data(), msg_data_size, false));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req, 1),
-    CreateMockWrite(*msg, 3),
+    CreateMockWrite(*req, 0),
+    CreateMockWrite(*msg, 2),
   };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> echo(
       spdy_util_.ConstructSpdyBodyFrame(
           1, msg_data.data(), msg_data_size, false));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId, msg_data_size));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    CreateMockRead(*echo, 4),
-    CreateMockRead(*window_update, 5),
-    MockRead(ASYNC, 0, 6)  // EOF
+    CreateMockRead(*resp, 1),
+    CreateMockRead(*echo, 3),
+    CreateMockRead(*window_update, 4),
+    MockRead(ASYNC, 0, 5)  // EOF
   };
 
   // Create SpdySession and SpdyStream and send the request.
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
@@ skipping 13 matching lines @@
   test::StreamDelegateSendImmediate delegate(stream, msg_data);
   stream->SetDelegate(&delegate);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
-  data.RunFor(2);
+  data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize - msg_data_size,
+  EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   data.RunFor(1);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize - msg_data_size,
+  EXPECT_EQ(kSpdySessionInitialWindowSize - msg_data_size,
             session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data.at_read_eof());
 
   EXPECT_EQ(msg_data, delegate.TakeReceivedData());
 
   // Draining the delegate's read queue should increase the session's
   // receive window.
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 
   stream->Close();
   EXPECT_EQ(NULL, stream.get());
 
   EXPECT_EQ(OK, delegate.WaitForClose());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
-  EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
+  EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 }
 
 // Given a stall function and an unstall function, runs a test to make
 // sure that a stream resumes after unstall.
 void SpdySessionTest::RunResumeAfterUnstallTest(
     const base::Callback<void(SpdySession*, SpdyStream*)>& stall_fn,
     const base::Callback<void(SpdySession*, SpdyStream*, int32)>&
         unstall_function) {
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req, 1),
-    CreateMockWrite(*body, 2),
+    CreateMockWrite(*req, 0),
+    CreateMockWrite(*body, 1),
   };
 
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> echo(
       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
   MockRead reads[] = {
-    CreateMockRead(*resp, 3),
-    MockRead(ASYNC, 0, 0, 4), // EOF
+    CreateMockRead(*resp, 2),
+    MockRead(ASYNC, 0, 0, 3), // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   CreateDeterministicNetworkSession();
@@ skipping 16 matching lines @@
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   stall_fn.Run(session.get(), stream.get());
 
-  data.RunFor(2);
+  data.RunFor(1);
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
   unstall_function.Run(session.get(), stream.get(), kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
@@ skipping 81 matching lines @@
 // increased.
 TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 3, kBodyDataSize, MEDIUM, NULL, 0));
   scoped_ptr<SpdyFrame> body1(
       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   scoped_ptr<SpdyFrame> body2(
       spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req1, 1),
-    CreateMockWrite(*req2, 2),
-    CreateMockWrite(*body2, 3),
-    CreateMockWrite(*body1, 4),
+    CreateMockWrite(*req1, 0),
+    CreateMockWrite(*req2, 1),
+    CreateMockWrite(*body2, 2),
+    CreateMockWrite(*body1, 3),
   };
 
   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   MockRead reads[] = {
-    CreateMockRead(*resp1, 5),
-    CreateMockRead(*resp2, 6),
-    MockRead(ASYNC, 0, 0, 7), // EOF
+    CreateMockRead(*resp1, 4),
+    CreateMockRead(*resp2, 5),
+    MockRead(ASYNC, 0, 0, 6), // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   CreateDeterministicNetworkSession();
@@ skipping 28 matching lines @@
 
   StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
-  data.RunFor(2);
+  data.RunFor(1);
   EXPECT_EQ(1u, stream1->stream_id());
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ skipping 65 matching lines @@
 // 0. Unstalling the session should properly handle deleted streams.
 TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> req3(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 5, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body2(
       spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req1, 1),
-    CreateMockWrite(*req2, 2),
-    CreateMockWrite(*req3, 3),
-    CreateMockWrite(*body2, 4),
+    CreateMockWrite(*req1, 0),
+    CreateMockWrite(*req2, 1),
+    CreateMockWrite(*req3, 2),
+    CreateMockWrite(*body2, 3),
   };
 
   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   MockRead reads[] = {
-    CreateMockRead(*resp2, 5),
-    MockRead(ASYNC, 0, 0, 6), // EOF
+    CreateMockRead(*resp2, 4),
+    MockRead(ASYNC, 0, 0, 5), // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   CreateDeterministicNetworkSession();
@@ skipping 39 matching lines @@
 
   StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
-  data.RunFor(2);
+  data.RunFor(1);
   EXPECT_EQ(1u, stream1->stream_id());
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ skipping 62 matching lines @@
 // being closed.
 TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
   if (GetParam() < kProtoSPDY31)
     return;
 
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body1(
       spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
   MockWrite writes[] = {
-    CreateMockWrite(*initial_window_update, 0),
-    CreateMockWrite(*req1, 1),
-    CreateMockWrite(*req2, 2),
+    CreateMockWrite(*req1, 0),
+    CreateMockWrite(*req2, 1),
   };
 
   MockRead reads[] = {
-    MockRead(ASYNC, 0, 0, 3), // EOF
+    MockRead(ASYNC, 0, 0, 2), // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
 
   CreateDeterministicNetworkSession();
@@ skipping 28 matching lines @@
 
   StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
-  data.RunFor(2);
+  data.RunFor(1);
   EXPECT_EQ(1u, stream1->stream_id());
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ skipping 18 matching lines @@
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
 
   EXPECT_TRUE(data.at_write_eof());
 }
 
+
 // Tests the case of a non-SPDY request closing an idle SPDY session when no
 // pointers to the idle session are currently held.
 TEST_P(SpdySessionTest, CloseOneIdleConnection) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 35 matching lines @@
   // The socket pool should close the connection asynchronously and establish a
   // new connection.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(pool->IsStalled());
 }
 
 // Tests the case of a non-SPDY request closing an idle SPDY session when no
 // pointers to the idle session are currently held, in the case the SPDY session
 // has an alias.
 TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 64 matching lines @@
 
   // The socket pool should close the connection asynchronously and establish a
   // new connection.
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_FALSE(pool->IsStalled());
 }
 
 // Tests the case of a non-SPDY request closing an idle SPDY session when a
 // pointer to the idle session is still held.
 TEST_P(SpdySessionTest, CloseOneIdleConnectionSessionStillHeld) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ skipping 39 matching lines @@
 
   // Release the pointer to the session so it can be closed.
   session1 = NULL;
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(pool->IsStalled());
 }
 
 // Tests that a non-SPDY request can't close a SPDY session that's currently in
 // use.
 TEST_P(SpdySessionTest, CloseOneIdleConnectionFailsWhenSessionInUse) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   scoped_ptr<SpdyFrame> req1(
@@ skipping 110 matching lines @@
   spdy_session_pool_->Remove(session_privacy_enabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_privacy_disabled));
 
   spdy_session_pool_->Remove(session_privacy_disabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_disabled));
 }
 
 }  // namespace net