[SPDY] Refactor SpdySession's write queue

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.h"
@@ skipping 65 matching lines @@
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       has_upload_data_(false),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0),
       domain_bound_cert_type_(CLIENT_CERT_INVALID_TYPE) {
 }
 
-class SpdyStream::SpdyStreamIOBufferProducer
-    : public SpdySession::SpdyIOBufferProducer {
+// A wrapper around a stream that calls into ProduceNextFrame().
+class SpdyStream::SpdyStreamFrameProducer : public SpdyFrameProducer {
  public:
-  SpdyStreamIOBufferProducer(SpdyStream* stream) : stream_(stream) {}
-
-  // SpdyFrameProducer
-  virtual RequestPriority GetPriority() const OVERRIDE {
-    return stream_->priority();
+  SpdyStreamFrameProducer(const scoped_refptr<SpdyStream>& stream)
+      : stream_(stream) {
+    DCHECK(stream_);
   }
 
-  virtual SpdyIOBuffer* ProduceNextBuffer(SpdySession* session) OVERRIDE {
-    if (stream_->cancelled())
-      return NULL;
-    if (stream_->stream_id() == 0)
-      SpdySession::SpdyIOBufferProducer::ActivateStream(session, stream_);
-    frame_ = stream_->ProduceNextFrame();
-    return frame_ == NULL ? NULL :
-        SpdySession::SpdyIOBufferProducer::CreateIOBuffer(
-            frame_.get(), GetPriority(), stream_);
+  virtual ~SpdyStreamFrameProducer() {}
+
+  virtual SpdyStream* GetStream() OVERRIDE {
+    return stream_.get();
+  }
+
+  virtual scoped_ptr<SpdyFrame> ProduceFrame() OVERRIDE {
+    DCHECK_GT(stream_->stream_id(), 0u);
+    return stream_->ProduceNextFrame();
   }
 
  private:
-  scoped_refptr<SpdyStream> stream_;
-  scoped_ptr<SpdyFrame> frame_;
+  const scoped_refptr<SpdyStream> stream_;
 };
 
 void SpdyStream::SetHasWriteAvailable() {
-  session_->SetStreamHasWriteAvailable(this,
-                                       new SpdyStreamIOBufferProducer(this));
+  session_->SetStreamHasWriteAvailable(
+      this,
+      scoped_ptr<SpdyFrameProducer>(new SpdyStreamFrameProducer(this)));
 }
 
 scoped_ptr<SpdyFrame> SpdyStream::ProduceNextFrame() {
   if (io_state_ == STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE) {
     CHECK(request_.get());
     CHECK_GT(stream_id_, 0u);
 
     std::string origin = GetUrl().GetOrigin().spec();
     DCHECK(origin[origin.length() - 1] == '/');
     origin.erase(origin.length() - 1);  // Trim trailing slash.
     scoped_ptr<SpdyFrame> frame(session_->CreateCredentialFrame(
         origin, domain_bound_cert_type_, domain_bound_private_key_,
         domain_bound_cert_, priority_));
     return frame.Pass();
-  } else if (io_state_ == STATE_SEND_HEADERS_COMPLETE) {
+  }
+
+  if (io_state_ == STATE_SEND_HEADERS_COMPLETE) {
     CHECK(request_.get());
     CHECK_GT(stream_id_, 0u);
 
     SpdyControlFlags flags =
         has_upload_data_ ? CONTROL_FLAG_NONE : CONTROL_FLAG_FIN;
     scoped_ptr<SpdyFrame> frame(session_->CreateSynStream(
         stream_id_, priority_, slot_, flags, *request_));
     send_time_ = base::TimeTicks::Now();
     return frame.Pass();
-  } else {
-    CHECK(!cancelled());
-    // We must need to write stream data.
-    // 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);
-    DCHECK_GT(stream_id_, 0u);
-    DCHECK(!pending_frames_.empty());
+  }
 
-    PendingFrame frame = pending_frames_.front();
-    pending_frames_.pop_front();
+  CHECK(!cancelled());
+  // We must need to write stream data.
+  // 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);
+  DCHECK_GT(stream_id_, 0u);
+  DCHECK(!pending_frames_.empty());
 
-    waiting_completions_.push_back(frame.type);
+  PendingFrame frame = pending_frames_.front();
+  pending_frames_.pop_front();
 
-    if (frame.type == TYPE_DATA) {
-      // Send queued data frame.
-      return scoped_ptr<SpdyFrame>(frame.data_frame);
-    } else {
-      DCHECK(frame.type == TYPE_HEADERS);
-      // Create actual HEADERS frame just in time because it depends on
-      // compression context and should not be reordered after the creation.
-      scoped_ptr<SpdyFrame> header_frame(session_->CreateHeadersFrame(
-          stream_id_, *frame.header_block, SpdyControlFlags()));
-      delete frame.header_block;
-      return header_frame.Pass();
-    }
+  waiting_completions_.push_back(frame.type);
+
+  if (frame.type == TYPE_DATA) {
+    // Send queued data frame.
+    return scoped_ptr<SpdyFrame>(frame.data_frame);
   }
-  NOTREACHED();
+
+  DCHECK(frame.type == TYPE_HEADERS);
+  // Create actual HEADERS frame just in time because it depends on
+  // compression context and should not be reordered after the creation.
+  scoped_ptr<SpdyFrame> header_frame(session_->CreateHeadersFrame(
+      stream_id_, *frame.header_block, SpdyControlFlags()));
+  delete frame.header_block;
+  return header_frame.Pass();
 }
 
 SpdyStream::~SpdyStream() {
   UpdateHistograms();
   while (!pending_frames_.empty()) {
     PendingFrame frame = pending_frames_.back();
     pending_frames_.pop_back();
     if (frame.type == TYPE_DATA)
       delete frame.data_frame;
     else
@@ skipping 706 matching lines @@
   }
 
   recv_window_size_ -= delta_window_size;
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
                  stream_id_, -delta_window_size, recv_window_size_));
 }
 
 }  // namespace net