Landing Recent QUIC changes until 4AM, Aug 7, 2016 UTC-4

net/quic/core/quic_session.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.
 //
 // A QuicSession, which demuxes a single connection to individual streams.
 
 #ifndef NET_QUIC_QUIC_SESSION_H_
 #define NET_QUIC_QUIC_SESSION_H_
 
 #include <stddef.h>
@@ skipping 39 matching lines @@
     // the server and thus the encryption key has been updated. Therefore the
     // connection should resend any packets that were sent under
     // ENCRYPTION_INITIAL. (Client only.)
     ENCRYPTION_REESTABLISHED,
     // HANDSHAKE_CONFIRMED, in a client, indicates the the server has accepted
     // our handshake. In a server it indicates that a full, valid client hello
     // has been received. (Client and server.)
     HANDSHAKE_CONFIRMED,
   };
 
-  // Takes ownership of |connection|.
+  // Does not take ownership of |connection|.
   QuicSession(QuicConnection* connection, const QuicConfig& config);
 
   ~QuicSession() override;
 
   virtual void Initialize();
 
   // QuicConnectionVisitorInterface methods:
   void OnStreamFrame(const QuicStreamFrame& frame) override;
   void OnRstStream(const QuicRstStreamFrame& frame) override;
   void OnGoAway(const QuicGoAwayFrame& frame) override;
@@ skipping 77 matching lines @@
 
   // Returns mutable config for this session. Returned config is owned
   // by QuicSession.
   QuicConfig* config();
 
   // Returns true if the stream existed previously and has been closed.
   // Returns false if the stream is still active or if the stream has
   // not yet been created.
   bool IsClosedStream(QuicStreamId id);
 
-  QuicConnection* connection() { return connection_.get(); }
-  const QuicConnection* connection() const { return connection_.get(); }
+  QuicConnection* connection() { return connection_; }
+  const QuicConnection* connection() const { return connection_; }
   size_t num_active_requests() const { return dynamic_stream_map_.size(); }
   const IPEndPoint& peer_address() const { return connection_->peer_address(); }
   QuicConnectionId connection_id() const {
     return connection_->connection_id();
   }
 
   // Returns the number of currently open streams, excluding the reserved
   // headers and crypto streams, and never counting unfinished streams.
   virtual size_t GetNumActiveStreams() const;
 
@@ skipping 175 matching lines @@
 
   // Called in OnConfigNegotiated when we receive a new connection level flow
   // control window in a negotiated config. Closes the connection if invalid.
   void OnNewSessionFlowControlWindow(QuicStreamOffset new_window);
 
   // Keep track of highest received byte offset of locally closed streams, while
   // waiting for a definitive final highest offset from the peer.
   std::map<QuicStreamId, QuicStreamOffset>
       locally_closed_streams_highest_offset_;
 
-  std::unique_ptr<QuicConnection> connection_;
+  QuicConnection* connection_;
 
   std::vector<ReliableQuicStream*> closed_streams_;
 
   QuicConfig config_;
 
   // The maximum number of outgoing streams this connection can open.
   size_t max_open_outgoing_streams_;
 
   // The maximum number of incoming streams this connection will allow.
   size_t max_open_incoming_streams_;
@@ skipping 41 matching lines @@
   // The stream id which was last popped in OnCanWrite, or 0, if not under the
   // call stack of OnCanWrite.
   QuicStreamId currently_writing_stream_id_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SESSION_H_