SPDY: Add WriteHeaders interface to SpdySession and SpdyStream

net/spdy/spdy_stream.cc

Index: net/spdy/spdy_stream.cc
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index 277188662eb1ea68559e2d2178b112b7021ecb15..d9e1c24488f288a65a58d13e0d4c50fbcb9c5224 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -136,19 +136,33 @@ SpdyFrame* SpdyStream::ProduceNextFrame() {
     // that our stream_id is correct.
     DCHECK_GT(io_state_, STATE_SEND_HEADERS_COMPLETE);
     DCHECK_GT(stream_id_, 0u);
-    DCHECK(!pending_data_frames_.empty());
-    SpdyFrame* frame = pending_data_frames_.front();
-    pending_data_frames_.pop_front();
-    return frame;
+    DCHECK(!pending_frames_.empty());
+
+    PendingFrame frame = pending_frames_.front();
+    pending_frames_.pop_front();
+
+    // Send queued data frame.
+    if (frame.type == TYPE_DATA)

[Ryan Hamilton, 2012/08/02 16:32:23]

This code is much cleaner now.  Nice!

nit:  I would probably write:
if (...) {
  // do data stuff
} else {
  DCHECK(frame.type == TYPE_HEADERS)
  // do headers stuff
}

but it's your call.

[Takashi Toyoshima, 2012/08/03 05:11:12]

looks safer.
I follow your idea.

Also, I added NOTREACHED() at the end of this function.

+      return frame.data.data_frame;
+
+    // Create actual HEADERS frame just in time because it depends on
+    // compression context and should not be reordered after the creation.
+    SpdyFrame* header_frame = session_->CreateHeadersFrame(
+        stream_id_, *frame.data.header_block, SpdyControlFlags());
+    delete frame.data.header_block;
+    return header_frame;
   }
 }
 
 SpdyStream::~SpdyStream() {
   UpdateHistograms();
-  while (!pending_data_frames_.empty()) {
-    SpdyFrame* frame = pending_data_frames_.back();
-    pending_data_frames_.pop_back();
-    delete frame;
+  while (!pending_frames_.empty()) {
+    PendingFrame frame = pending_frames_.back();
+    pending_frames_.pop_back();
+    if (frame.type == TYPE_DATA)
+      delete frame.data.data_frame;
+    else
+      delete frame.data.header_block;
   }
 }
 
@@ -555,15 +569,38 @@ int SpdyStream::SendRequest(bool has_upload_data) {
   return DoLoop(OK);
 }
 
-int SpdyStream::WriteStreamData(IOBuffer* data, int length,
+int SpdyStream::WriteHeaders(SpdyHeaderBlock* headers) {
+  // Until the first headers by SYN_STREAM have been completely sent, we can
+  // not be sure that our stream_id is correct.
+  DCHECK_GT(io_state_, STATE_SEND_HEADERS_COMPLETE);
+  CHECK_GT(stream_id_, 0u);
+
+  PendingFrame frame;
+  frame.type = TYPE_HEADER;
+  frame.data.header_block = headers;
+  pending_frames_.push_back(frame);
+
+  SetHasWriteAvailable();
+  return ERR_IO_PENDING;
+}
+
+int SpdyStream::WriteStreamData(IOBuffer* data,
+                                int length,
                                 SpdyDataFlags flags) {
   // Until the headers have been completely sent, we can not be sure
   // that our stream_id is correct.
   DCHECK_GT(io_state_, STATE_SEND_HEADERS_COMPLETE);
   CHECK_GT(stream_id_, 0u);
 
-  pending_data_frames_.push_back(
-      session_->CreateDataFrame(stream_id_, data, length, flags));
+  SpdyDataFrame* data_frame = session_->CreateDataFrame(
+      stream_id_, data, length, flags);
+  if (!data_frame)
+    return ERR_IO_PENDING;
+
+  PendingFrame frame;
+  frame.type = TYPE_DATA;
+  frame.data.data_frame = data_frame;
+  pending_frames_.push_back(frame);
 
   SetHasWriteAvailable();
   return ERR_IO_PENDING;