Land Recent QUIC changes.

net/quic/quic_session.cc

 // 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.
 
 #include "net/quic/quic_session.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/ssl/ssl_info.h"
@@ skipping 15 matching lines @@
 // To avoid deleting a stream in mid-operation, we have a simple shim between
 // us and the stream, so we can delete any streams when we return from
 // processing.
 //
 // We could just override the base methods, but this makes it easier to make
 // sure we don't miss any.
 class VisitorShim : public QuicConnectionVisitorInterface {
  public:
   explicit VisitorShim(QuicSession* session) : session_(session) {}
 
-  virtual bool OnPacket(const IPEndPoint& self_address,
-                        const IPEndPoint& peer_address,
-                        const QuicPacketHeader& header,
-                        const vector<QuicStreamFrame>& frame) OVERRIDE {
-    bool accepted = session_->OnPacket(self_address, peer_address, header,
-                                       frame);
+  virtual bool OnStreamFrames(const vector<QuicStreamFrame>& frames) OVERRIDE {
+    bool accepted = session_->OnStreamFrames(frames);
     session_->PostProcessAfterData();
     return accepted;
   }
   virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
   virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE {
     session_->OnGoAway(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnAck(const SequenceNumberSet& acked_packets) OVERRIDE {
-    session_->OnAck(acked_packets);
-    session_->PostProcessAfterData();
-  }
-
   virtual bool OnCanWrite() OVERRIDE {
     bool rc = session_->OnCanWrite();
     session_->PostProcessAfterData();
     return rc;
   }
 
   virtual void OnSuccessfulVersionNegotiation(
       const QuicVersion& version) OVERRIDE {
     session_->OnSuccessfulVersionNegotiation(version);
   }
 
   virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE {
     session_->ConnectionClose(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
 
+  virtual bool HasPendingHandshake() const OVERRIDE {
+    return session_->HasPendingHandshake();
+  }
+
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection,
                          const QuicConfig& config,
                          bool is_server)
     : connection_(connection),
       visitor_shim_(new VisitorShim(this)),
       config_(config),
       max_open_streams_(config_.max_streams_per_connection()),
       next_stream_id_(is_server ? 2 : 3),
       is_server_(is_server),
       largest_peer_created_stream_id_(0),
       error_(QUIC_NO_ERROR),
       goaway_received_(false),
-      goaway_sent_(false) {
+      goaway_sent_(false),
+      has_pending_handshake_(false) {
 
   connection_->set_visitor(visitor_shim_.get());
   connection_->SetIdleNetworkTimeout(config_.idle_connection_state_lifetime());
   if (connection_->connected()) {
     connection_->SetOverallConnectionTimeout(
         config_.max_time_before_crypto_handshake());
   }
   // TODO(satyamshekhar): Set congestion control and ICSL also.
 }
 
 QuicSession::~QuicSession() {
   STLDeleteElements(&closed_streams_);
   STLDeleteValues(&stream_map_);
 }
 
-bool QuicSession::OnPacket(const IPEndPoint& self_address,
-                           const IPEndPoint& peer_address,
-                           const QuicPacketHeader& header,
-                           const vector<QuicStreamFrame>& frames) {
-  if (header.public_header.guid != connection()->guid()) {
-    DLOG(INFO) << ENDPOINT << "Got packet header for invalid GUID: "
-               << header.public_header.guid;
-    return false;
-  }
-
+bool QuicSession::OnStreamFrames(const vector<QuicStreamFrame>& frames) {
   for (size_t i = 0; i < frames.size(); ++i) {
     // TODO(rch) deal with the error case of stream id 0
     if (IsClosedStream(frames[i].stream_id)) {
       // If we get additional frames for a stream where we didn't process
       // headers, it's highly likely our compression context will end up
       // permanently out of sync with the peer's, so we give up and close the
       // connection.
       if (ContainsKey(prematurely_closed_streams_, frames[i].stream_id)) {
         connection()->SendConnectionClose(
             QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
@@ skipping 87 matching lines @@
 }
 
 bool QuicSession::OnCanWrite() {
   // We latch this here rather than doing a traditional loop, because streams
   // may be modifying the list as we loop.
   int remaining_writes = write_blocked_streams_.NumBlockedStreams();
 
   while (!connection_->HasQueuedData() &&
          remaining_writes > 0) {
     DCHECK(write_blocked_streams_.HasWriteBlockedStreams());
-    ReliableQuicStream* stream = NULL;
     int index = write_blocked_streams_.GetHighestPriorityWriteBlockedList();
-    if (index != -1) {
-      stream = GetStream(write_blocked_streams_.PopFront(index));
+    if (index == -1) {
+      LOG(DFATAL) << "WriteBlockedStream is missing";
+      connection_->CloseConnection(QUIC_INTERNAL_ERROR, false);
+      return true;  // We have no write blocked streams.
     }
+    QuicStreamId stream_id = write_blocked_streams_.PopFront(index);
+    if (stream_id == kCryptoStreamId) {
+      has_pending_handshake_ = false;  // We just popped it.
+    }
+    ReliableQuicStream* stream = GetStream(stream_id);
     if (stream != NULL) {
       // If the stream can't write all bytes, it'll re-add itself to the blocked
       // list.
       stream->OnCanWrite();
     }
     --remaining_writes;
   }
 
   return !write_blocked_streams_.HasWriteBlockedStreams();
 }
 
+bool QuicSession::HasPendingHandshake() const {
+  return has_pending_handshake_;
+}
+
 QuicConsumedData QuicSession::WritevData(QuicStreamId id,
                                          const struct iovec* iov,
-                                         int count,
+                                         int iov_count,
                                          QuicStreamOffset offset,
                                          bool fin) {
-  return connection_->SendvStreamData(id, iov, count, offset, fin);
+  return connection_->SendvStreamData(id, iov, iov_count, offset, fin);
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error) {
   connection_->SendRstStream(id, error);
   CloseStreamInner(id, true);
 }
 
 void QuicSession::SendGoAway(QuicErrorCode error_code, const string& reason) {
   goaway_sent_ = true;
@@ skipping 117 matching lines @@
     const CryptoHandshakeMessage& message) {
 }
 
 QuicConfig* QuicSession::config() {
   return &config_;
 }
 
 void QuicSession::ActivateStream(ReliableQuicStream* stream) {
   DLOG(INFO) << ENDPOINT << "num_streams: " << stream_map_.size()
              << ". activating " << stream->id();
-  DCHECK(stream_map_.count(stream->id()) == 0);
+  DCHECK_EQ(stream_map_.count(stream->id()), 0u);
   stream_map_[stream->id()] = stream;
 }
 
 QuicStreamId QuicSession::GetNextStreamId() {
   QuicStreamId id = next_stream_id_;
   next_stream_id_ += 2;
   return id;
 }
 
 ReliableQuicStream* QuicSession::GetStream(const QuicStreamId stream_id) {
@@ skipping 79 matching lines @@
   return id <= largest_peer_created_stream_id_ &&
       implicitly_created_streams_.count(id) == 0;
 }
 
 size_t QuicSession::GetNumOpenStreams() const {
   return stream_map_.size() + implicitly_created_streams_.size() -
       zombie_streams_.size();
 }
 
 void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
+  if (id == kCryptoStreamId) {
+    DCHECK(!has_pending_handshake_);
+    has_pending_handshake_ = true;
+    // TODO(jar): Be sure to use the highest priority for the crypto stream,
+    // perhaps by adding a "special" priority for it that is higher than
+    // kHighestPriority.
+    priority = kHighestPriority;
+  }
   write_blocked_streams_.PushBack(id, priority);
 }
 
 void QuicSession::MarkDecompressionBlocked(QuicHeaderId header_id,
                                            QuicStreamId stream_id) {
   decompression_blocked_streams_[header_id] = stream_id;
 }
 
 bool QuicSession::GetSSLInfo(SSLInfo* ssl_info) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void QuicSession::PostProcessAfterData() {
   STLDeleteElements(&closed_streams_);
   closed_streams_.clear();
 }
 
 }  // namespace net