Add a queued_data_bytes() method to ReliableQuicStream. Not used outside of tests.

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.
 
 // It does not contain the entire interface needed by an application to interact
 // with a QUIC stream.  Some parts of the interface must be obtained by
 // accessing the owning session object.  A subclass of ReliableQuicStream
 // connects the object and the application that generates and consumes the data
@@ skipping 95 matching lines @@
   bool reading_stopped() const {
     return sequencer_.ignore_read_data() || read_side_closed_;
   }
   bool write_side_closed() const { return write_side_closed_; }
 
   bool rst_received() { return rst_received_; }
   bool rst_sent() { return rst_sent_; }
   bool fin_received() { return fin_received_; }
   bool fin_sent() { return fin_sent_; }
 
+  uint64 queued_data_bytes() const { return queued_data_bytes_; }
+
   uint64 stream_bytes_read() const { return stream_bytes_read_; }
   uint64 stream_bytes_written() const { return stream_bytes_written_; }
 
   void set_fin_sent(bool fin_sent) { fin_sent_ = fin_sent; }
   void set_fin_received(bool fin_received) { fin_received_ = fin_received; }
   void set_rst_sent(bool rst_sent) { rst_sent_ = rst_sent; }
 
   void set_fec_policy(FecPolicy fec_policy) { fec_policy_ = fec_policy; }
   FecPolicy fec_policy() const { return fec_policy_; }
 
@@ skipping 113 matching lines @@
     scoped_refptr<QuicAckListenerInterface> ack_listener;
   };
 
   // Calls MaybeSendBlocked on the stream's flow controller and the connection
   // level flow controller.  If the stream is flow control blocked by the
   // connection-level flow controller but not by the stream-level flow
   // controller, marks this stream as connection-level write blocked.
   void MaybeSendBlocked();
 
   std::list<PendingData> queued_data_;
+  // How many bytes are queued?
+  uint64 queued_data_bytes_;
 
   QuicStreamSequencer sequencer_;
   QuicStreamId id_;
   // Pointer to the owning QuicSession object.
   QuicSession* session_;
   // Bytes read and written refer to payload bytes only: they do not include
   // framing, encryption overhead etc.
   uint64 stream_bytes_read_;
   uint64 stream_bytes_written_;
 
@@ skipping 44 matching lines @@
   // connection level flow control limits (but are stream level flow control
   // limited).
   bool stream_contributes_to_connection_flow_control_;
 
   DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_