Land Recent QUIC changes.

net/quic/reliable_quic_stream.h

 // 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.
 //
 // The base class for client/server reliable streams.
 
 #ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
 #define NET_QUIC_RELIABLE_QUIC_STREAM_H_
 
 #include <sys/types.h>
@@ skipping 77 matching lines @@
   // been fully processed.  Then they simply delegate to the sequencer.
   virtual size_t Readv(const struct iovec* iov, size_t iov_len);
   virtual int GetReadableRegions(iovec* iov, size_t iov_len);
   virtual bool IsHalfClosed() const;
   virtual bool HasBytesToRead() const;
 
   // Called by the session when a decompression blocked stream
   // becomes unblocked.
   virtual void OnDecompressorAvailable();
 
+  // By default, this is the same as priority(), however it allows streams
+  // to temporarily alter effective priority.   For example if a SPDY stream has
+  // compressed but not written headers it can write the headers with a higher
+  // priority.
+  virtual QuicPriority EffectivePriority() const;
+
   QuicStreamId id() const { return id_; }
 
   QuicRstStreamErrorCode stream_error() const { return stream_error_; }
   QuicErrorCode connection_error() const { return connection_error_; }
 
   bool read_side_closed() const { return read_side_closed_; }
   bool write_side_closed() const { return write_side_closed_; }
 
   uint64 stream_bytes_read() { return stream_bytes_read_; }
   uint64 stream_bytes_written() { return stream_bytes_written_; }
 
   const IPEndPoint& GetPeerAddress() const;
 
   void set_visitor(Visitor* visitor) { visitor_ = visitor; }
 
   QuicSpdyCompressor* compressor();
 
   // Gets the SSL connection information.
   bool GetSSLInfo(SSLInfo* ssl_info);
 
   bool headers_decompressed() const { return headers_decompressed_; }
-  QuicPriority priority() const { return priority_; }
 
  protected:
   // Returns a pair with the number of bytes consumed from data, and a boolean
   // indicating if the fin bit was consumed.  This does not indicate the data
   // has been sent on the wire: it may have been turned into a packet and queued
   // if the socket was unexpectedly blocked.
   //
   // The default implementation always consumed all bytes and any fin, but
   // this behavior is not guaranteed for subclasses so callers should check the
   // return value.
   virtual QuicConsumedData WriteData(base::StringPiece data, bool fin);
 
   // Close the read side of the socket.  Further frames will not be accepted.
   virtual void CloseReadSide();
 
   // Close the write side of the socket.  Further writes will fail.
   void CloseWriteSide();
 
   bool HasBufferedData();
 
   bool fin_buffered() { return fin_buffered_; }
 
   QuicSession* session() { return session_; }
 
+  // Sets priority_ to priority.  This should only be called before bytes are
+  // written to the server.
+  void set_priority(QuicPriority priority);
+  // This is protected because external classes should use EffectivePriority
+  // instead.
+  QuicPriority priority() const { return priority_; }
+
   // Sends as much of 'data' to the connection as the connection will consume,
   // and then buffers any remaining data in queued_data_.
   // Returns (data.size(), true) as it always consumed all data: it returns for
   // convenience to have the same return type as WriteDataInternal.
   QuicConsumedData WriteOrBuffer(base::StringPiece data, bool fin);
 
   // Sends as much of 'data' to the connection as the connection will consume.
   // Returns the number of bytes consumed by the connection.
   QuicConsumedData WriteDataInternal(base::StringPiece data, bool fin);
 
+  // Sends as many bytes in the first |count| buffers of |iov| to the connection
+  // as the connection will consume.
+  // Returns the number of bytes consumed by the connection.
+  QuicConsumedData WritevDataInternal(const struct iovec* iov,
+                                      int count,
+                                      bool fin);
+
  private:
   friend class test::ReliableQuicStreamPeer;
   friend class QuicStreamUtils;
 
   uint32 StripPriorityAndHeaderId(const char* data, uint32 data_len);
 
   std::list<string> queued_data_;
 
   QuicStreamSequencer sequencer_;
   QuicStreamId id_;
@@ skipping 34 matching lines @@
 
   // True if the priority has been read, false otherwise.
   bool priority_parsed_;
   bool fin_buffered_;
   bool fin_sent_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_