[SPDY] Refactor SpdySession's write queue

net/spdy/spdy_write_queue.h

Index: net/spdy/spdy_write_queue.h
diff --git a/net/spdy/spdy_write_queue.h b/net/spdy/spdy_write_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..637369b18b140c5ec94e08fc3bbb58cb50cc9d56
--- /dev/null
+++ b/net/spdy/spdy_write_queue.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2013 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.
+
+#ifndef NET_SPDY_SPDY_WRITE_QUEUE_H_
+#define NET_SPDY_SPDY_WRITE_QUEUE_H_
+
+#include <deque>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/net_export.h"
+#include "net/base/request_priority.h"
+
+namespace net {
+
+class SpdyFrame;
+class SpdyStream;
+
+// An object which provides a SpdyFrame for writing. We pass these
+// around instead of SpdyFrames since some frames have to be generated
+// "just in time".
+class NET_EXPORT_PRIVATE SpdyFrameProducer {
+ public:
+  SpdyFrameProducer();
+
+  // Produces the frame to be written. Will be called at most once.
+  virtual scoped_ptr<SpdyFrame> ProduceFrame() = 0;
+
+  virtual ~SpdyFrameProducer();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SpdyFrameProducer);
+};
+
+// A simple wrapper around a single SpdyFrame.
+class NET_EXPORT_PRIVATE SimpleFrameProducer : public SpdyFrameProducer {
+ public:
+  explicit SimpleFrameProducer(scoped_ptr<SpdyFrame> frame);
+
+  virtual ~SimpleFrameProducer();
+
+  virtual scoped_ptr<SpdyFrame> ProduceFrame() OVERRIDE;
+
+ private:
+  scoped_ptr<SpdyFrame> frame_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimpleFrameProducer);
+};
+
+// A queue of SpdyFrameProducers to produce frames to write. Ordered
+// by priority, and then FIFO.
+class NET_EXPORT_PRIVATE SpdyWriteQueue {

[Ryan Hamilton, 2013/03/28 15:51:04]

Since this WriteQueue is only used by the Session, I think I would split the
producer definitions out into spdy_frame_producer.h which spdy_stream would
include, leaving only the producer in this file which would be included by
spdy_session.

[akalin, 2013/04/06 01:17:48]

Done.

+ public:
+  SpdyWriteQueue();
+  ~SpdyWriteQueue();
+
+  // Enqueues the given frame producer at the given priority
+  // associated with the given stream, which may be NULL if the frame
+  // producer is associated with the session.

[Ryan Hamilton, 2013/03/28 15:51:04]

nit: if the frame is *not* associated with *a stream*.

I think?

[akalin, 2013/04/06 01:17:48]

Done.

+  void Enqueue(RequestPriority priority,
+               scoped_ptr<SpdyFrameProducer> frame_producer,
+               const scoped_refptr<SpdyStream>& stream);

[Ryan Hamilton, 2013/03/28 15:51:04]

out of curiosity, why is this a const scoped_refptr& and not a scoped_refptr?

[akalin, 2013/04/06 01:17:48]

it saves a ref inc/dec. habit I picked up from willchan.

+
+  // Dequeues the next frame producer and its associated

[Ryan Hamilton, 2013/03/28 15:51:04]

nit: Can you comment on the ordering guarantees of Dequeue.  In particular the
fifo behavior within a priority, and priority order amongst priorities.  You
mention the ordering at the class comment, but it think it would be helpful to
mention here, since the ordering really comes into play here. 

[akalin, 2013/04/06 01:17:48]

Done.

+  // stream. Returns true and fills in |frame_producer| and |stream|
+  // if successful -- otherwise, just returns false.
+  bool Dequeue(scoped_ptr<SpdyFrameProducer>* frame_producer,
+               scoped_refptr<SpdyStream>* stream);
+
+  // Removes all pending writes for the given stream, which must be
+  // non-NULL.
+  void RemovePendingWritesForStream(const scoped_refptr<SpdyStream>& stream);
+
+  // Removes all pending writes.
+  void Clear();
+
+ private:
+  // A struct holding a frame producer and its associated stream.
+  struct PendingWrite {
+    // This has to be a raw pointer since we store this in an STL
+    // container.
+    SpdyFrameProducer* frame_producer;
+    scoped_refptr<SpdyStream> stream;
+
+    PendingWrite();
+    PendingWrite(SpdyFrameProducer* frame_producer,
+                 const scoped_refptr<SpdyStream>& stream);
+    ~PendingWrite();
+  };
+
+  // The actual write queue, binned by priority.
+  std::deque<PendingWrite> queue_[NUM_PRIORITIES];
+
+  DISALLOW_COPY_AND_ASSIGN(SpdyWriteQueue);
+};
+
+}  // namespace
+
+#endif  // NET_SPDY_SPDY_WRITE_QUEUE_H_