Land Recent QUIC changes.

net/quic/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 <vector>
@@ skipping 41 matching lines @@
     HANDSHAKE_CONFIRMED,
   };
 
   QuicSession(QuicConnection* connection,
               const QuicConfig& config,
               bool is_server);
 
   virtual ~QuicSession();
 
   // QuicConnectionVisitorInterface methods:
-  virtual bool OnPacket(const IPEndPoint& self_address,
-                        const IPEndPoint& peer_address,
-                        const QuicPacketHeader& header,
-                        const std::vector<QuicStreamFrame>& frame) OVERRIDE;
+  virtual bool OnStreamFrames(
+      const std::vector<QuicStreamFrame>& frames) OVERRIDE;
   virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE;
   virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE;
   virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE;
   virtual void OnSuccessfulVersionNegotiation(
       const QuicVersion& version) OVERRIDE{}
   // Not needed for HTTP.
-  virtual void OnAck(const SequenceNumberSet& acked_packets) OVERRIDE {}
   virtual bool OnCanWrite() OVERRIDE;
+  virtual bool HasPendingHandshake() const OVERRIDE;
 
   // Called by streams when they want to write data to the peer.
   // 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.
   virtual QuicConsumedData WritevData(QuicStreamId id,
                                       const struct iovec* iov,
-                                      int count,
+                                      int iov_count,
                                       QuicStreamOffset offset,
                                       bool fin);
 
   // Called by streams when they want to close the stream in both directions.
   virtual void SendRstStream(QuicStreamId id, QuicRstStreamErrorCode error);
 
   // Called when the session wants to go away and not accept any new streams.
   void SendGoAway(QuicErrorCode error_code, const std::string& reason);
 
   // Removes the stream associated with 'stream_id' from the active stream map.
@@ skipping 186 matching lines @@
   QuicStreamId largest_peer_created_stream_id_;
 
   // The latched error with which the connection was closed.
   QuicErrorCode error_;
 
   // Whether a GoAway has been received.
   bool goaway_received_;
   // Whether a GoAway has been sent.
   bool goaway_sent_;
 
+  // Indicate if there is pending data for the crypto stream.
+  bool has_pending_handshake_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SESSION_H_