Landing Recent QUIC changes until 12:43 PM, Nov 5, 2016 UTC+8

net/quic/core/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.
+// The base class for client/server QUIC 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
+// accessing the owning session object.  A subclass of QuicStream
 // connects the object and the application that generates and consumes the data
 // of the stream.
 
-// The ReliableQuicStream object has a dependent QuicStreamSequencer object,
+// The QuicStream object has a dependent QuicStreamSequencer object,
 // which is given the stream frames as they arrive, and provides stream data in
 // order by invoking ProcessRawData().
 
-#ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
-#define NET_QUIC_RELIABLE_QUIC_STREAM_H_
+#ifndef NET_QUIC_CORE_QUIC_STREAM_H_
+#define NET_QUIC_CORE_QUIC_STREAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 
 #include <list>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_piece.h"
 #include "net/base/iovec.h"
 #include "net/base/net_export.h"
 #include "net/quic/core/quic_flow_controller.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_stream_sequencer.h"
 #include "net/quic/core/quic_types.h"
 
 namespace net {
 
 namespace test {
-class ReliableQuicStreamPeer;
+class QuicStreamPeer;
 }  // namespace test
 
 class QuicSession;
 
-class NET_EXPORT_PRIVATE ReliableQuicStream {
+class NET_EXPORT_PRIVATE QuicStream {
  public:
-  ReliableQuicStream(QuicStreamId id, QuicSession* session);
+  QuicStream(QuicStreamId id, QuicSession* session);
 
-  virtual ~ReliableQuicStream();
+  virtual ~QuicStream();
 
   // Not in use currently.
   void SetFromConfig();
 
   // Called by the session when a (potentially duplicate) stream frame has been
   // received for this stream.
   virtual void OnStreamFrame(const QuicStreamFrame& frame);
 
   // Called by the session when the connection becomes writeable to allow the
   // stream to write any pending data.
@@ skipping 156 matching lines @@
   QuicSession* session() { return session_; }
 
   const QuicStreamSequencer* sequencer() const { return &sequencer_; }
   QuicStreamSequencer* sequencer() { return &sequencer_; }
 
   void DisableConnectionFlowControlForThisStream() {
     stream_contributes_to_connection_flow_control_ = false;
   }
 
  private:
-  friend class test::ReliableQuicStreamPeer;
+  friend class test::QuicStreamPeer;
   friend class QuicStreamUtils;
 
   // Close the read side of the socket.  May cause the stream to be closed.
   // Subclasses and consumers should use StopReading to terminate reading early.
   void CloseReadSide();
 
   // Subclasses and consumers should use reading_stopped.
   bool read_side_closed() const { return read_side_closed_; }
 
   struct PendingData {
@@ skipping 69 matching lines @@
   QuicFlowController* connection_flow_controller_;
 
   // Special streams, such as the crypto and headers streams, do not respect
   // connection level flow control limits (but are stream level flow control
   // limited).
   bool stream_contributes_to_connection_flow_control_;
 
   // For debugging only, used for busy loop check.
   size_t busy_counter_;
 
-  DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
+  DISALLOW_COPY_AND_ASSIGN(QuicStream);
 };
 
 }  // namespace net
 
-#endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_
+#endif  // NET_QUIC_CORE_QUIC_STREAM_H_