Increase read buffer size for SPDY upload

net/spdy/spdy_network_transaction_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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
@@ skipping 36 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 namespace {
 
 using testing::Each;
 using testing::Eq;
 
+// This currently 16kB.

[Bence, 2016/04/26 16:59:23]

I think it would be better to remove this comment, because it is especially
prone to becoming out-of-date.

[xunjieli, 2016/04/26 17:03:16]

Done.

+const int32_t kBufferSize = SpdyHttpStream::kRequestBodyBufferSize;
+
 enum SpdyNetworkTransactionTestSSLType {
   // Request an https:// URL and use NPN (or ALPN) to negotiate SPDY during
   // the TLS handshake.
   HTTPS_SPDY_VIA_NPN,
   // Request and http:// URL to a server that supports SPDY via Alternative
   // Service on port 443.
   // See: https//tools.ietf.org/id/draft-ietf-httpbis-alt-svc-06.html
   HTTP_SPDY_VIA_ALT_SVC,
 };
 
@@ skipping 6457 matching lines @@
 // ("hello!") is not permitted to go through since by the time its turn
 // arrives, window size is 0.  At this point MessageLoop::Run() called via
 // callback would block.  Therefore we call MessageLoop::RunUntilIdle()
 // which returns after performing all possible writes.  We use DCHECKS to
 // ensure that last data frame is still there and stream has stalled.
 // After that, next read is artifically enforced, which causes a
 // WINDOW_UPDATE to be read and I/O process resumes.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) {
   const int32_t initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
-  // Number of frames we need to send to zero out the window size: data
-  // frames plus SYN_STREAM plus the last data frame; also we need another
-  // data frame that we will send once the WINDOW_UPDATE is received,
-  // therefore +3.
-  size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
-
-  // Calculate last frame's size; 0 size data frame is legal.
-  size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
+  // Number of upload data buffers we need to send to zero out the window size
+  // is the minimal number of upload buffers takes to be bigger than
+  // |initial_window_size|.
+  size_t num_upload_buffers =
+      ceil(static_cast<double>(initial_window_size) / kBufferSize);
+  // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
+  // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
+  // which has kBufferSize % kMaxSpdyChunkSize bytes.
+  size_t num_frames_in_one_upload_buffer =
+      ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, initial_window_size + kUploadDataSize, LOWEST, NULL,
-      0));
+      GetDefaultUrl(), 1,
+      /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
+      LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
-  // Last frame to zero out the window size.
+  // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
-      1, content.c_str(), last_frame_size, false));
+      1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
-  // Data frame to be sent once WINDOW_UPDATE frame is received.
-  std::unique_ptr<SpdySerializedFrame> body3(
+  // The very last frame before the stalled frames.
+  std::unique_ptr<SpdySerializedFrame> body3(spdy_util_.ConstructSpdyBodyFrame(
+      1, content.c_str(),
+      initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
+
+  // Data frames to be sent once WINDOW_UPDATE frame is received.
+
+  // If kBufferSize * num_upload_buffers > initial_window_size,
+  // we need one additional frame to send the rest of 'a'.
+  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                        'a');
+  std::unique_ptr<SpdySerializedFrame> body4(spdy_util_.ConstructSpdyBodyFrame(
+      1, last_body.c_str(), last_body.size(), false));
+
+  // Also send a "hello!" after WINDOW_UPDATE.
+  std::unique_ptr<SpdySerializedFrame> body5(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   // Fill in mock writes.
-  std::unique_ptr<MockWrite[]> writes(new MockWrite[num_writes]);
   size_t i = 0;
-  writes[i] = CreateMockWrite(*req, i);
-  for (i = 1; i < num_writes - 2; i++)
-    writes[i] = CreateMockWrite(*body1, i);
-  writes[i] = CreateMockWrite(*body2, i);
-  // The last write must not be attempted until after the WINDOW_UPDATES
-  // have been received.
-  writes[i + 1] = CreateMockWrite(*body3, i + 4, SYNCHRONOUS);
+  std::vector<MockWrite> writes;
+  writes.push_back(CreateMockWrite(*req, i++));
+  for (size_t j = 0; j < num_upload_buffers; j++) {
+    for (size_t k = 0; k < num_frames_in_one_upload_buffer; k++) {
+      if (k == num_frames_in_one_upload_buffer - 1 &&
+          kBufferSize % kMaxSpdyFrameChunkSize != 0) {
+        if (j == num_upload_buffers - 1 &&
+            (initial_window_size % kBufferSize != 0)) {
+          writes.push_back(CreateMockWrite(*body3, i++));
+        } else {
+          writes.push_back(CreateMockWrite(*body2, i++));
+        }
+      } else {
+        writes.push_back(CreateMockWrite(*body1, i++));
+      }
+    }
+  }
 
-  // Construct read frame, give enough space to upload the rest of the
-  // data.
+  // Fill in mock reads.
+  std::vector<MockRead> reads;
+  // Force a pause.
+  reads.push_back(MockRead(ASYNC, ERR_IO_PENDING, i++));
+  // Construct read frame for window updates that gives enough space to upload
+  // the rest of the data.
   std::unique_ptr<SpdySerializedFrame> session_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
+      spdy_util_.ConstructSpdyWindowUpdate(0,
+                                           kUploadDataSize + last_body.size()));
   std::unique_ptr<SpdySerializedFrame> window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize));
+      spdy_util_.ConstructSpdyWindowUpdate(1,
+                                           kUploadDataSize + last_body.size()));
+
+  reads.push_back(CreateMockRead(*session_window_update, i++));
+  reads.push_back(CreateMockRead(*window_update, i++));
+
+  // Stalled frames which can be sent after receiving window updates.
+  if (last_body.size() > 0)
+    writes.push_back(CreateMockWrite(*body4, i++));
+  writes.push_back(CreateMockWrite(*body5, i++));
+
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
-  MockRead reads[] = {
-      MockRead(ASYNC, ERR_IO_PENDING, i + 1),  // Force a pause
-      CreateMockRead(*session_window_update, i + 2),
-      CreateMockRead(*window_update, i + 3),
-      // Now the last write will occur.
-      CreateMockRead(*reply, i + 5),
-      CreateMockRead(*body2, i + 6),
-      CreateMockRead(*body3, i + 7),
-      MockRead(ASYNC, 0, i + 8)  // EOF
-  };
+  reads.push_back(CreateMockRead(*reply, i++));
+  reads.push_back(CreateMockRead(*body2, i++));
+  reads.push_back(CreateMockRead(*body5, i++));
+  reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
-  SequencedSocketData data(reads, arraysize(reads), writes.get(), num_writes);
+  SequencedSocketData data(reads.data(), reads.size(), writes.data(),
+                           writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(initial_window_size, 'a');
+  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
-  NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
-                                     BoundNetLog(), GetParam(), NULL);
+  NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
+                                     GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   base::RunLoop().RunUntilIdle();  // Write as much as we can.
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
-  // All the body data should have been read.
-  // TODO(satorux): This is because of the weirdness in reading the request
-  // body in OnSendBodyComplete(). See crbug.com/113107.
-  EXPECT_TRUE(upload_data_stream.IsEOF());
+  if (initial_window_size % kBufferSize != 0) {
+    // If it does not take whole number of full upload buffer to zero out
+    // initial window size, then the upload data is not at EOF, because the
+    // last read must be stalled.
+    EXPECT_FALSE(upload_data_stream.IsEOF());
+  } else {
+    // All the body data should have been read.
+    // TODO(satorux): This is because of the weirdness in reading the request
+    // body in OnSendBodyComplete(). See crbug.com/113107.
+    EXPECT_TRUE(upload_data_stream.IsEOF());
+  }
   // But the body is not yet fully sent (kUploadData is not yet sent)
   // since we're send-stalled.
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
   data.Resume();  // Read in WINDOW_UPDATE frame.
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in
 // unstalling the send window.
 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) {
   const int32_t initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
-
-  // Number of frames we need to send to zero out the window size: data
-  // frames plus SYN_STREAM plus the last data frame; also we need another
-  // data frame that we will send once the SETTING is received, therefore +3.
-  size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
-
-  // Calculate last frame's size; 0 size data frame is legal.
-  size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
+  // Number of upload data buffers we need to send to zero out the window size
+  // is the minimal number of upload buffers takes to be bigger than
+  // |initial_window_size|.
+  size_t num_upload_buffers =
+      ceil(static_cast<double>(initial_window_size) / kBufferSize);
+  // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
+  // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
+  // which has kBufferSize % kMaxSpdyChunkSize bytes.
+  size_t num_frames_in_one_upload_buffer =
+      ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, initial_window_size + kUploadDataSize, LOWEST, NULL,
-      0));
+      GetDefaultUrl(), 1,
+      /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
+      LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
-  // Last frame to zero out the window size.
+  // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
-      1, content.c_str(), last_frame_size, false));
+      1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
-  // Data frame to be sent once SETTINGS frame is received.
-  std::unique_ptr<SpdySerializedFrame> body3(
+  // The very last frame before the stalled frames.
+  std::unique_ptr<SpdySerializedFrame> body3(spdy_util_.ConstructSpdyBodyFrame(
+      1, content.c_str(),
+      initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
+
+  // Data frames to be sent once WINDOW_UPDATE frame is received.
+
+  // If kBufferSize * num_upload_buffers > initial_window_size,
+  // we need one additional frame to send the rest of 'a'.
+  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                        'a');
+  std::unique_ptr<SpdySerializedFrame> body4(spdy_util_.ConstructSpdyBodyFrame(
+      1, last_body.c_str(), last_body.size(), false));
+
+  // Also send a "hello!" after WINDOW_UPDATE.
+  std::unique_ptr<SpdySerializedFrame> body5(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
-  // Fill in mock reads/writes.
+  // Fill in mock writes.
+  size_t i = 0;
+  std::vector<MockWrite> writes;
+  writes.push_back(CreateMockWrite(*req, i++));
+  for (size_t j = 0; j < num_upload_buffers; j++) {
+    for (size_t k = 0; k < num_frames_in_one_upload_buffer; k++) {
+      if (k == num_frames_in_one_upload_buffer - 1 &&
+          kBufferSize % kMaxSpdyFrameChunkSize != 0) {
+        if (j == num_upload_buffers - 1 &&
+            (initial_window_size % kBufferSize != 0)) {
+          writes.push_back(CreateMockWrite(*body3, i++));
+        } else {
+          writes.push_back(CreateMockWrite(*body2, i++));
+        }
+      } else {
+        writes.push_back(CreateMockWrite(*body1, i++));
+      }
+    }
+  }
+
+  // Fill in mock reads.
   std::vector<MockRead> reads;
-  std::vector<MockWrite> writes;
-  size_t i = 0;
-  writes.push_back(CreateMockWrite(*req, i++));
-  while (i < num_writes - 2)
-    writes.push_back(CreateMockWrite(*body1, i++));
-  writes.push_back(CreateMockWrite(*body2, i++));
-
+  // Force a pause.
   reads.push_back(MockRead(ASYNC, ERR_IO_PENDING, i++));
 
   // Construct read frame for SETTINGS that gives enough space to upload the
   // rest of the data.
   SettingsMap settings;
   settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, initial_window_size * 2);
   std::unique_ptr<SpdySerializedFrame> settings_frame_large(
       spdy_util_.ConstructSpdySettings(settings));
 
   reads.push_back(CreateMockRead(*settings_frame_large, i++));
 
   std::unique_ptr<SpdySerializedFrame> session_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
+      spdy_util_.ConstructSpdyWindowUpdate(0,
+                                           last_body.size() + kUploadDataSize));
   reads.push_back(CreateMockRead(*session_window_update, i++));
 
   std::unique_ptr<SpdySerializedFrame> settings_ack(
       spdy_util_.ConstructSpdySettingsAck());
   writes.push_back(CreateMockWrite(*settings_ack, i++));
 
-  writes.push_back(CreateMockWrite(*body3, i++));
+  // Stalled frames which can be sent after |settings_ack|.
+  if (last_body.size() > 0)
+    writes.push_back(CreateMockWrite(*body4, i++));
+  writes.push_back(CreateMockWrite(*body5, i++));
 
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
-  reads.push_back(CreateMockRead(*body3, i++));
+  reads.push_back(CreateMockRead(*body5, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(initial_window_size, 'a');
+  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data.RunUntilPaused();  // Write as much as we can.
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
 
-  // All the body data should have been read.
-  // TODO(satorux): This is because of the weirdness in reading the request
-  // body in OnSendBodyComplete(). See crbug.com/113107.
-  EXPECT_TRUE(upload_data_stream.IsEOF());
+  if (initial_window_size % kBufferSize != 0) {
+    // If it does not take whole number of full upload buffer to zero out
+    // initial window size, then the upload data is not at EOF, because the
+    // last read must be stalled.
+    EXPECT_FALSE(upload_data_stream.IsEOF());
+  } else {
+    // All the body data should have been read.
+    // TODO(satorux): This is because of the weirdness in reading the request
+    // body in OnSendBodyComplete(). See crbug.com/113107.
+    EXPECT_TRUE(upload_data_stream.IsEOF());
+  }
   // But the body is not yet fully sent (kUploadData is not yet sent)
   // since we're send-stalled.
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
   // Read in SETTINGS frame to unstall.
   data.Resume();
   base::RunLoop().RunUntilIdle();
 
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
   // If stream is NULL, that means it was unstalled and closed.
   EXPECT_TRUE(stream->stream() == NULL);
 }
 
 // Test we correctly handle the case where the SETTINGS frame results in a
 // negative send window size.
 TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) {
   const int32_t initial_window_size =
       SpdySession::GetDefaultInitialWindowSize(GetParam().protocol);
-  // Number of frames we need to send to zero out the window size: data
-  // frames plus SYN_STREAM plus the last data frame; also we need another
-  // data frame that we will send once the SETTING is received, therefore +3.
-  size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
-
-  // Calculate last frame's size; 0 size data frame is legal.
-  size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
+  // Number of upload data buffers we need to send to zero out the window size
+  // is the minimal number of upload buffers takes to be bigger than
+  // |initial_window_size|.
+  size_t num_upload_buffers =
+      ceil(static_cast<double>(initial_window_size) / kBufferSize);
+  // Each upload data buffer consists of |num_frames_in_one_upload_buffer|
+  // frames, each with |kMaxSpdyFrameChunkSize| bytes except the last frame,
+  // which has kBufferSize % kMaxSpdyChunkSize bytes.
+  size_t num_frames_in_one_upload_buffer =
+      ceil(static_cast<double>(kBufferSize) / kMaxSpdyFrameChunkSize);
 
   // Construct content for a data frame of maximum size.
   std::string content(kMaxSpdyFrameChunkSize, 'a');
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
-      GetDefaultUrl(), 1, initial_window_size + kUploadDataSize, LOWEST, NULL,
-      0));
+      GetDefaultUrl(), 1,
+      /*content_length=*/kBufferSize * num_upload_buffers + kUploadDataSize,
+      LOWEST, NULL, 0));
 
   // Full frames.
   std::unique_ptr<SpdySerializedFrame> body1(spdy_util_.ConstructSpdyBodyFrame(
       1, content.c_str(), content.size(), false));
 
-  // Last frame to zero out the window size.
+  // Last frame in each upload data buffer.
   std::unique_ptr<SpdySerializedFrame> body2(spdy_util_.ConstructSpdyBodyFrame(
-      1, content.c_str(), last_frame_size, false));
+      1, content.c_str(), kBufferSize % kMaxSpdyFrameChunkSize, false));
 
-  // Data frame to be sent once SETTINGS frame is received.
-  std::unique_ptr<SpdySerializedFrame> body3(
+  // The very last frame before the stalled frames.
+  std::unique_ptr<SpdySerializedFrame> body3(spdy_util_.ConstructSpdyBodyFrame(
+      1, content.c_str(),
+      initial_window_size % kBufferSize % kMaxSpdyFrameChunkSize, false));
+
+  // Data frames to be sent once WINDOW_UPDATE frame is received.
+
+  // If kBufferSize * num_upload_buffers > initial_window_size,
+  // we need one additional frame to send the rest of 'a'.
+  std::string last_body(kBufferSize * num_upload_buffers - initial_window_size,
+                        'a');
+  std::unique_ptr<SpdySerializedFrame> body4(spdy_util_.ConstructSpdyBodyFrame(
+      1, last_body.c_str(), last_body.size(), false));
+
+  // Also send a "hello!" after WINDOW_UPDATE.
+  std::unique_ptr<SpdySerializedFrame> body5(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
-  // Fill in mock reads/writes.
+  // Fill in mock writes.
+  size_t i = 0;
+  std::vector<MockWrite> writes;
+  writes.push_back(CreateMockWrite(*req, i++));
+  for (size_t j = 0; j < num_upload_buffers; j++) {
+    for (size_t k = 0; k < num_frames_in_one_upload_buffer; k++) {
+      if (k == num_frames_in_one_upload_buffer - 1 &&
+          kBufferSize % kMaxSpdyFrameChunkSize != 0) {
+        if (j == num_upload_buffers - 1 &&
+            (initial_window_size % kBufferSize != 0)) {
+          writes.push_back(CreateMockWrite(*body3, i++));
+        } else {
+          writes.push_back(CreateMockWrite(*body2, i++));
+        }
+      } else {
+        writes.push_back(CreateMockWrite(*body1, i++));
+      }
+    }
+  }
+
+  // Fill in mock reads.
   std::vector<MockRead> reads;
-  std::vector<MockWrite> writes;
-  size_t i = 0;
-  writes.push_back(CreateMockWrite(*req, i++));
-  while (i < num_writes - 2)
-    writes.push_back(CreateMockWrite(*body1, i++));
-  writes.push_back(CreateMockWrite(*body2, i++));
-
+  // Force a pause.
   reads.push_back(MockRead(ASYNC, ERR_IO_PENDING, i++));
-
   // Construct read frame for SETTINGS that makes the send_window_size
   // negative.
   SettingsMap new_settings;
   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, initial_window_size / 2);
   std::unique_ptr<SpdySerializedFrame> settings_frame_small(
       spdy_util_.ConstructSpdySettings(new_settings));
   // Construct read frames for WINDOW_UPDATE that makes the send_window_size
   // positive.
   std::unique_ptr<SpdySerializedFrame> session_window_update_init_size(
       spdy_util_.ConstructSpdyWindowUpdate(0, initial_window_size));
   std::unique_ptr<SpdySerializedFrame> window_update_init_size(
       spdy_util_.ConstructSpdyWindowUpdate(1, initial_window_size));
 
   reads.push_back(CreateMockRead(*settings_frame_small, i++));
   reads.push_back(CreateMockRead(*session_window_update_init_size, i++));
   reads.push_back(CreateMockRead(*window_update_init_size, i++));
 
   std::unique_ptr<SpdySerializedFrame> settings_ack(
       spdy_util_.ConstructSpdySettingsAck());
   writes.push_back(CreateMockWrite(*settings_ack, i++));
 
-  writes.push_back(CreateMockWrite(*body3, i++));
+  // Stalled frames which can be sent after |settings_ack|.
+  if (last_body.size() > 0)
+    writes.push_back(CreateMockWrite(*body4, i++));
+  writes.push_back(CreateMockWrite(*body5, i++));
 
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
-  reads.push_back(CreateMockRead(*body3, i++));
+  reads.push_back(CreateMockRead(*body5, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                            writes.size());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  std::string upload_data_string(initial_window_size, 'a');
+  std::string upload_data_string(kBufferSize * num_upload_buffers, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size())));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   data.RunUntilPaused();  // Write as much as we can.
   base::RunLoop().RunUntilIdle();
 
   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
   ASSERT_TRUE(stream != NULL);
   ASSERT_TRUE(stream->stream() != NULL);
   EXPECT_EQ(0, stream->stream()->send_window_size());
 
-  // All the body data should have been read.
-  // TODO(satorux): This is because of the weirdness in reading the request
-  // body in OnSendBodyComplete(). See crbug.com/113107.
-  EXPECT_TRUE(upload_data_stream.IsEOF());
-  // But the body is not yet fully sent (kUploadData is not yet sent)
-  // since we're send-stalled.
-  EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
+  if (initial_window_size % kBufferSize != 0) {
+    // If it does not take whole number of full upload buffer to zero out
+    // initial window size, then the upload data is not at EOF, because the
+    // last read must be stalled.
+    EXPECT_FALSE(upload_data_stream.IsEOF());
+  } else {
+    // All the body data should have been read.
+    // TODO(satorux): This is because of the weirdness in reading the request
+    // body in OnSendBodyComplete(). See crbug.com/113107.
+    EXPECT_TRUE(upload_data_stream.IsEOF());
+  }
 
   // Read in WINDOW_UPDATE or SETTINGS frame.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnOddPushStreamId) {
   std::unique_ptr<SpdyHeaderBlock> push_headers(new SpdyHeaderBlock);
@@ skipping 242 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net