src/net/spdy/spdy_write_queue.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_SPDY_SPDY_WRITE_QUEUE_H_
   6 #define NET_SPDY_SPDY_WRITE_QUEUE_H_
   7
   8 #include <deque>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "net/base/net_export.h"
  14 #include "net/base/request_priority.h"
  15 #include "net/spdy/spdy_protocol.h"
  16
  17 namespace net {
  18
  19 class SpdyBuffer;
  20 class SpdyBufferProducer;
  21 class SpdyStream;
  22
  23 // A queue of SpdyBufferProducers to produce frames to write. Ordered
  24 // by priority, and then FIFO.
  25 class NET_EXPORT_PRIVATE SpdyWriteQueue {
  26  public:
  27   SpdyWriteQueue();
  28   ~SpdyWriteQueue();
  29
  30   // Returns whether there is anything in the write queue,
  31   // i.e. whether the next call to Dequeue will return true.
  32   bool IsEmpty() const;
  33
  34   // Enqueues the given frame producer of the given type at the given
  35   // priority associated with the given stream, which may be NULL if
  36   // the frame producer is not associated with a stream. If |stream|
  37   // is non-NULL, its priority must be equal to |priority|, and it
  38   // must remain non-NULL until the write is dequeued or removed.
  39   void Enqueue(RequestPriority priority,
  40                SpdyFrameType frame_type,
  41                scoped_ptr<SpdyBufferProducer> frame_producer,
  42                const base::WeakPtr<SpdyStream>& stream);
  43
  44   // Dequeues the frame producer with the highest priority that was
  45   // enqueued the earliest and its associated stream. Returns true and
  46   // fills in |frame_type|, |frame_producer|, and |stream| if
  47   // successful -- otherwise, just returns false.
  48   bool Dequeue(SpdyFrameType* frame_type,
  49                scoped_ptr<SpdyBufferProducer>* frame_producer,
  50                base::WeakPtr<SpdyStream>* stream);
  51
  52   // Removes all pending writes for the given stream, which must be
  53   // non-NULL.
  54   void RemovePendingWritesForStream(const base::WeakPtr<SpdyStream>& stream);
  55
  56   // Removes all pending writes for streams after |last_good_stream_id|
  57   // and streams with no stream id.
  58   void RemovePendingWritesForStreamsAfter(SpdyStreamId last_good_stream_id);
  59
  60   // Removes all pending writes.
  61   void Clear();
  62
  63  private:
  64   // A struct holding a frame producer and its associated stream.
  65   struct PendingWrite {
  66     SpdyFrameType frame_type;
  67     // This has to be a raw pointer since we store this in an STL
  68     // container.
  69     SpdyBufferProducer* frame_producer;
  70     base::WeakPtr<SpdyStream> stream;
  71     // Whether |stream| was non-NULL when enqueued.
  72     bool has_stream;
  73
  74     PendingWrite();
  75     PendingWrite(SpdyFrameType frame_type,
  76                  SpdyBufferProducer* frame_producer,
  77                  const base::WeakPtr<SpdyStream>& stream);
  78     ~PendingWrite();
  79   };
  80
  81   bool removing_writes_;
  82
  83   // The actual write queue, binned by priority.
  84   std::deque<PendingWrite> queue_[NUM_PRIORITIES];
  85
  86   DISALLOW_COPY_AND_ASSIGN(SpdyWriteQueue);
  87 };
  88
  89 }  // namespace net
  90
  91 #endif  // NET_SPDY_SPDY_WRITE_QUEUE_H_