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 45 matching lines @@
     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.
   }
 
  private:
   QuicSession* session_;
 };
 
 QuicSession::QuicSession(QuicConnection* connection,
@@ skipping 150 matching lines @@
       // 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();
 }
 
-QuicConsumedData QuicSession::WriteData(QuicStreamId id,
-                                        StringPiece data,
-                                        QuicStreamOffset offset,
-                                        bool fin) {
-  return connection_->SendStreamData(id, data, offset, fin);
+QuicConsumedData QuicSession::WritevData(QuicStreamId id,
+                                         const struct iovec* iov,
+                                         int count,
+                                         QuicStreamOffset offset,
+                                         bool fin) {
+  return connection_->SendvStreamData(id, 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 216 matching lines @@
   // streams.
   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) {
-  write_blocked_streams_.PushBack(id, 0);
+void QuicSession::MarkWriteBlocked(QuicStreamId id, QuicPriority priority) {
+  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