[SPDY] Remove more code related to sending HEADERS frames

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 <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 123 matching lines @@
 }
 
 void SpdyStream::PushedStreamReplayData() {
   DCHECK_NE(stream_id_, 0u);
 
   if (!delegate_)
     return;
 
   continue_buffering_data_ = false;
 
+  // TODO(akalin): This call may delete this object. Figure out what
+  // to do in that case.
   int rv = delegate_->OnResponseReceived(*response_, response_time_, OK);
   if (rv == ERR_INCOMPLETE_SPDY_HEADERS) {
     // We don't have complete headers.  Assume we're waiting for another
     // HEADERS frame.  Since we don't have headers, we had better not have
     // any pending data frames.
     if (pending_buffers_.size() != 0U) {
       LogStreamError(ERR_SPDY_PROTOCOL_ERROR,
                      "HEADERS incomplete headers, but pending data frames.");
       session_->CloseActiveStream(stream_id_, ERR_SPDY_PROTOCOL_ERROR);
     }
@@ skipping 228 matching lines @@
   *response_ = response;  // TODO(ukai): avoid copy.
 
   recv_first_byte_time_ = base::TimeTicks::Now();
   response_time_ = base::Time::Now();
 
   // If we receive a response before we are in STATE_WAITING_FOR_RESPONSE, then
   // the server has sent the SYN_REPLY too early.
   if (!pushed_ && io_state_ != STATE_WAITING_FOR_RESPONSE)
     return ERR_SPDY_PROTOCOL_ERROR;
   if (pushed_)
-    CHECK(io_state_ == STATE_NONE);
+    CHECK_EQ(io_state_, STATE_NONE);
   io_state_ = STATE_OPEN;
 
   // Append all the headers into the response header block.
   for (SpdyHeaderBlock::const_iterator it = response.begin();
        it != response.end(); ++it) {
     // Disallow uppercase headers.
     if (ContainsUpperAscii(it->first)) {
       session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                             "Upper case characters in header: " + it->first);
       return ERR_SPDY_PROTOCOL_ERROR;
     }
   }
 
   if ((*response_).find("transfer-encoding") != (*response_).end()) {
     session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
-  if (delegate_)
+  if (delegate_) {
+    // May delete this object.
     rv = delegate_->OnResponseReceived(*response_, response_time_, rv);
+  }
   // If delegate_ is not yet attached, we'll call OnResponseReceived after the
   // delegate gets attached to the stream.
 
   return rv;
 }
 
 int SpdyStream::OnHeaders(const SpdyHeaderBlock& headers) {
   DCHECK(!response_->empty());
 
   // Append all the headers into the response header block.
@@ skipping 17 matching lines @@
   }
 
   if ((*response_).find("transfer-encoding") != (*response_).end()) {
     session_->ResetStream(stream_id_, priority_, RST_STREAM_PROTOCOL_ERROR,
                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   int rv = OK;
   if (delegate_) {
+    // May delete this object.
     rv = delegate_->OnResponseReceived(*response_, response_time_, rv);
     // ERR_INCOMPLETE_SPDY_HEADERS means that we are waiting for more
     // headers before the response header block is complete.
     if (rv == ERR_INCOMPLETE_SPDY_HEADERS)
       rv = OK;
   }
   return rv;
 }
 
 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
@@ skipping 360 matching lines @@
 // DoSendBody is called to send the optional body for the request.  This call
 // will also be called as each write of a chunk of the body completes.
 int SpdyStream::DoSendBody() {
   io_state_ = STATE_SEND_BODY_COMPLETE;
   CHECK(delegate_);
   delegate_->OnSendBody();
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::DoSendBodyComplete(int result) {
+  result = ProcessJustCompletedFrame(result, STATE_SEND_BODY_COMPLETE);
+
   if (result != OK)
     return result;
 
+  SpdySendStatus send_status = delegate_->OnSendBodyComplete();
+
+  io_state_ =
+      (send_status == MORE_DATA_TO_SEND) ?
+      STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
+
+  return OK;
+}
+
+int SpdyStream::DoOpen() {
+  int result = ProcessJustCompletedFrame(OK, STATE_OPEN);
+
+  if (result != OK)
+    return result;
+
+  // Set |io_state_| first as |delegate_| may check it.
+  io_state_ = STATE_OPEN;
+
+  delegate_->OnDataSent();
+
+  return OK;
+}
+
+int SpdyStream::ProcessJustCompletedFrame(int result, State io_pending_state) {
+  if (result != OK)
+    return result;
+
   if (just_completed_frame_type_ != DATA) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   if (just_completed_frame_size_ < session_->GetDataFrameMinimumSize()) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   size_t frame_payload_size =
       just_completed_frame_size_ - session_->GetDataFrameMinimumSize();
   if (frame_payload_size > session_->GetDataFrameMaximumPayload()) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   send_bytes_ += frame_payload_size;
 
   pending_send_data_->DidConsume(frame_payload_size);
   if (pending_send_data_->BytesRemaining() > 0) {
-    io_state_ = STATE_SEND_BODY_COMPLETE;
+    io_state_ = io_pending_state;
     QueueNextDataFrame();
     return ERR_IO_PENDING;
   }
 
   pending_send_data_ = NULL;
   pending_send_flags_ = DATA_FLAG_NONE;
 
   if (!delegate_) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  io_state_ =
-      (delegate_->OnSendBodyComplete() == MORE_DATA_TO_SEND) ?
-      STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
-
-  return OK;
-}
-
-int SpdyStream::DoOpen() {
-  io_state_ = STATE_OPEN;
-
-  switch (just_completed_frame_type_) {
-    case DATA: {
-      if (just_completed_frame_size_ < session_->GetDataFrameMinimumSize()) {
-        NOTREACHED();
-        return ERR_UNEXPECTED;
-      }
-
-      size_t frame_payload_size =
-          just_completed_frame_size_ - session_->GetDataFrameMinimumSize();
-      if (frame_payload_size > session_->GetDataFrameMaximumPayload()) {
-        NOTREACHED();
-        return ERR_UNEXPECTED;
-      }
-
-      send_bytes_ += frame_payload_size;
-
-      pending_send_data_->DidConsume(frame_payload_size);
-      if (pending_send_data_->BytesRemaining() > 0) {
-        QueueNextDataFrame();
-        return ERR_IO_PENDING;
-      }
-
-      pending_send_data_ = NULL;
-      pending_send_flags_ = DATA_FLAG_NONE;
-
-      if (delegate_)
-        delegate_->OnDataSent();
-
-      break;
-    }
-
-    case HEADERS:
-      if (delegate_)
-        delegate_->OnHeadersSent();
-      break;
-
-    default:
-      NOTREACHED();
-      return ERR_UNEXPECTED;
-  }
-
   return OK;
 }
 
 void SpdyStream::UpdateHistograms() {
   // We need all timers to be filled in, otherwise metrics can be bogus.
   if (send_time_.is_null() || recv_first_byte_time_.is_null() ||
       recv_last_byte_time_.is_null())
     return;
 
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTimeToFirstByte",
@@ skipping 38 matching lines @@
                    GetWeakPtr(), payload_size));
   }
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 }  // namespace net