Allow SPDY POSTs to be terminated by an empty FIN data frame.

net/spdy/spdy_stream.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_stream.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 776 matching lines @@
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 void SpdyStream::QueueNextDataFrame() {
   // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
   CHECK(io_state_ == STATE_OPEN ||
         io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
   CHECK_GT(stream_id_, 0u);
   CHECK(pending_send_data_.get());
-  CHECK_GT(pending_send_data_->BytesRemaining(), 0);
+  // Only the final fame may have a length of 0.

[mef, 2014/08/26 12:58:41]

nit: fame -> frame.

+  if (pending_send_status_ == NO_MORE_DATA_TO_SEND) {
+    CHECK_GE(pending_send_data_->BytesRemaining(), 0);
+  } else {
+    CHECK_GT(pending_send_data_->BytesRemaining(), 0);
+  }
 
   SpdyDataFlags flags =
       (pending_send_status_ == NO_MORE_DATA_TO_SEND) ?
       DATA_FLAG_FIN : DATA_FLAG_NONE;
   scoped_ptr<SpdyBuffer> data_buffer(
       session_->CreateDataBuffer(stream_id_,
                                  pending_send_data_.get(),
                                  pending_send_data_->BytesRemaining(),
                                  flags));
   // We'll get called again by PossiblyResumeIfSendStalled().
   if (!data_buffer)
     return;
 
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     DCHECK_GE(data_buffer->GetRemainingSize(),
               session_->GetDataFrameMinimumSize());
     size_t payload_size =
         data_buffer->GetRemainingSize() - session_->GetDataFrameMinimumSize();
     DCHECK_LE(payload_size, session_->GetDataFrameMaximumPayload());
-    DecreaseSendWindowSize(static_cast<int32>(payload_size));
-    // This currently isn't strictly needed, since write frames are
-    // discarded only if the stream is about to be closed. But have it
-    // here anyway just in case this changes.
-    data_buffer->AddConsumeCallback(
-        base::Bind(&SpdyStream::OnWriteBufferConsumed,
-                   GetWeakPtr(), payload_size));
+
+    // Send window size is based on payload size, so nothing to do if this is
+    // just a FIN with no payload.
+    if (payload_size != 0) {
+      DecreaseSendWindowSize(static_cast<int32>(payload_size));
+      // This currently isn't strictly needed, since write frames are
+      // discarded only if the stream is about to be closed. But have it
+      // here anyway just in case this changes.
+      data_buffer->AddConsumeCallback(
+          base::Bind(&SpdyStream::OnWriteBufferConsumed,
+                     GetWeakPtr(), payload_size));
+    }
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 int SpdyStream::MergeWithResponseHeaders(
     const SpdyHeaderBlock& new_response_headers) {
@@ skipping 69 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net