[SPDY] Fix bug where a SPDY stream might not unstall properly in all cases

net/spdy/spdy_session_spdy3_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 "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_data_directory.h"
 #include "net/base/test_data_stream.h"
 #include "net/dns/host_cache.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session_pool.h"
@@ skipping 20 matching lines @@
 const base::StringPiece kBodyDataStringPiece(kBodyData, kBodyDataSize);
 
 static int g_delta_seconds = 0;
 base::TimeTicks TheNearFuture() {
   return base::TimeTicks::Now() + base::TimeDelta::FromSeconds(g_delta_seconds);
 }
 
 }  // namespace
 
 class SpdySessionSpdy3Test : public PlatformTest {
+ public:
+  // Functions used with RunResumeAfterUnstallTest31().
+
+  void StallSessionOnly(SpdySession* session, SpdyStream* stream) {
+    StallSessionSend(session);
+  }
+
+  void StallStreamOnly(SpdySession* session, SpdyStream* stream) {
+    StallStreamSend(stream);
+  }
+
+  void StallSessionStream(SpdySession* session, SpdyStream* stream) {
+    StallSessionSend(session);
+    StallStreamSend(stream);
+  }
+
+  void StallStreamSession(SpdySession* session, SpdyStream* stream) {
+    StallStreamSend(stream);
+    StallSessionSend(session);
+  }
+
+  void UnstallSessionOnly(SpdySession* session,
+                          SpdyStream* stream,
+                          int32 delta_window_size) {
+    UnstallSessionSend(session, delta_window_size);
+  }
+
+  void UnstallStreamOnly(SpdySession* session,
+                         SpdyStream* stream,
+                         int32 delta_window_size) {
+    UnstallStreamSend(stream, delta_window_size);
+  }
+
+  void UnstallSessionStream(SpdySession* session,
+                            SpdyStream* stream,
+                            int32 delta_window_size) {
+    UnstallSessionSend(session, delta_window_size);
+    UnstallStreamSend(stream, delta_window_size);
+  }
+
+  void UnstallStreamSession(SpdySession* session,
+                            SpdyStream* stream,
+                            int32 delta_window_size) {
+    UnstallStreamSend(stream, delta_window_size);
+    UnstallSessionSend(session, delta_window_size);
+  }
+
  protected:
   SpdySessionSpdy3Test()
       : spdy_session_pool_(NULL),
         test_url_(kTestUrl),
         test_host_port_pair_(kTestHost, kTestPort),
         pair_(test_host_port_pair_, ProxyServer::Direct()) {
   }
 
   virtual void SetUp() {
     g_delta_seconds = 0;
@@ skipping 50 matching lines @@
     while (session->session_send_window_size_ > 0) {
       session->DecreaseSendWindowSize(
           std::min(kMaxSpdyFrameChunkSize, session->session_send_window_size_));
     }
   }
 
   void UnstallSessionSend(SpdySession* session, int32 delta_window_size) {
     session->IncreaseSendWindowSize(delta_window_size);
   }
 
+  void StallStreamSend(SpdyStream* stream) {
+    // Reduce the send window size to 0 to stall.
+    while (stream->send_window_size() > 0) {
+      stream->DecreaseSendWindowSize(
+          std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
+    }
+  }
+
+  void UnstallStreamSend(SpdyStream* stream, int32 delta_window_size) {
+    stream->IncreaseSendWindowSize(delta_window_size);
+  }
+
+  void RunResumeAfterUnstallTest31(
+      const base::Callback<void(SpdySession*, SpdyStream*)>& stall_fn,
+      const base::Callback<void(SpdySession*, SpdyStream*, int32)>& unstall_fn);
+
   scoped_refptr<TransportSocketParams> transport_params_;
   SpdySessionDependencies session_deps_;
   scoped_refptr<HttpNetworkSession> http_session_;
   SpdySessionPool* spdy_session_pool_;
   GURL test_url_;
   HostPortPair test_host_port_pair_;
   HostPortProxyPair pair_;
 };
 
 TEST_F(SpdySessionSpdy3Test, GoAway) {
@@ skipping 2467 matching lines @@
 
   stream->Close();
 
   EXPECT_EQ(OK, delegate.WaitForClose());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 }
 
-// Cause a stall by reducing the flow control send window to 0. The
-// stream should resume when that window is then increased.
-TEST_F(SpdySessionSpdy3Test, ResumeAfterSendWindowSizeIncrease31) {
+// Given a stall function and an unstall function, runs a test to make
+// sure that a stream resumes after unstall.
+void SpdySessionSpdy3Test::RunResumeAfterUnstallTest31(
+    const base::Callback<void(SpdySession*, SpdyStream*)>& stall_fn,
+    const base::Callback<void(SpdySession*, SpdyStream*, int32)>& unstall_fn) {
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.enable_spdy_31 = true;
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   scoped_ptr<SpdyFrame> initial_window_update(
       ConstructSpdyWindowUpdate(
           kSessionFlowControlStreamId,
           kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
@@ skipping 43 matching lines @@
       ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   data.RunFor(3);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  stall_fn.Run(session, stream);
 
   EXPECT_EQ(ERR_IO_PENDING, delegate.OnSendBody());
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
-  UnstallSessionSend(session, kBodyDataSize);
+  unstall_fn.Run(session, stream, kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
   EXPECT_EQ(kBodyDataStringPiece.as_string(), delegate.TakeReceivedData());
   EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate.body_data_sent());
 }
 
+// Run the resume-after-unstall test with all possible stall and
+// unstall sequences.
+
+TEST_F(SpdySessionSpdy3Test, ResumeAfterUnstallSession31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallSessionOnly,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallSessionOnly,
+                 base::Unretained(this)));
+}
+
+// Equivalent to
+// SpdyStreamSpdy3Test.ResumeAfterSendWindowSizeIncrease.
+TEST_F(SpdySessionSpdy3Test, ResumeAfterUnstallStream31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallStreamOnly,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallStreamOnly,
+                 base::Unretained(this)));
+}
+
+TEST_F(SpdySessionSpdy3Test,
+       StallSessionStreamResumeAfterUnstallSessionStream31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallSessionStream,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallSessionStream,
+                 base::Unretained(this)));
+}
+
+TEST_F(SpdySessionSpdy3Test,
+       StallStreamSessionResumeAfterUnstallSessionStream31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallStreamSession,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallSessionStream,
+                 base::Unretained(this)));
+}
+
+TEST_F(SpdySessionSpdy3Test,
+       StallStreamSessionResumeAfterUnstallStreamSession31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallStreamSession,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallStreamSession,
+                 base::Unretained(this)));
+}
+
+TEST_F(SpdySessionSpdy3Test,
+       StallSessionStreamResumeAfterUnstallStreamSession31) {
+  RunResumeAfterUnstallTest31(
+      base::Bind(&SpdySessionSpdy3Test::StallSessionStream,
+                 base::Unretained(this)),
+      base::Bind(&SpdySessionSpdy3Test::UnstallStreamSession,
+                 base::Unretained(this)));
+}
+
 // Cause a stall by reducing the flow control send window to 0. The
 // streams should resume in priority order when that window is then
 // increased.
 TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.enable_spdy_31 = true;
   session_deps_.host_resolver->set_synchronous_mode(true);
 
@@ skipping 478 matching lines @@
   EXPECT_EQ(0, delegate1.body_data_sent());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate2.GetResponseHeaderValue(":version"));
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
   EXPECT_EQ(0, delegate2.body_data_sent());
 }
 
 }  // namespace net