Landing Recent QUIC changes until and including Mon Nov 16 14:15:48 2015

net/quic/quic_headers_stream.cc

 // Copyright 2013 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_headers_stream.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_headers_stream.h"
@@ skipping 186 matching lines @@
       spdy_framer_(HTTP2),
       spdy_framer_visitor_(new SpdyFramerVisitor(this)) {
   spdy_framer_.set_visitor(spdy_framer_visitor_.get());
   spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
   // The headers stream is exempt from connection level flow control.
   DisableConnectionFlowControlForThisStream();
 }
 
 QuicHeadersStream::~QuicHeadersStream() {}
 
-size_t QuicHeadersStream::WriteHeaders(
-    QuicStreamId stream_id,
-    const SpdyHeaderBlock& headers,
-    bool fin,
-    QuicPriority priority,
-    QuicAckListenerInterface* ack_notifier_delegate) {
+size_t QuicHeadersStream::WriteHeaders(QuicStreamId stream_id,
+                                       const SpdyHeaderBlock& headers,
+                                       bool fin,
+                                       SpdyPriority priority,
+                                       QuicAckListenerInterface* ack_listener) {
   SpdyHeadersIR headers_frame(stream_id);
   headers_frame.set_header_block(headers);
   headers_frame.set_fin(fin);
   if (session()->perspective() == Perspective::IS_CLIENT) {
     headers_frame.set_has_priority(true);
     headers_frame.set_priority(priority);
   }
   scoped_ptr<SpdySerializedFrame> frame(
       spdy_framer_.SerializeFrame(headers_frame));
   WriteOrBufferData(StringPiece(frame->data(), frame->size()), false,
-                    ack_notifier_delegate);
+                    ack_listener);
   return frame->size();
 }
 
+size_t QuicHeadersStream::WritePushPromise(
+    QuicStreamId original_stream_id,
+    QuicStreamId promised_stream_id,
+    const SpdyHeaderBlock& headers,
+    QuicAckListenerInterface* ack_listener) {
+  if (session()->perspective() == Perspective::IS_CLIENT) {
+    LOG(DFATAL) << "Client shouldn't send PUSH_PROMISE";
+    return 0;
+  }
+
+  SpdyPushPromiseIR push_promise(original_stream_id, promised_stream_id);
+  push_promise.set_header_block(headers);
+  // PUSH_PROMISE must not be the last frame sent out, at least followed by
+  // response headers.
+  push_promise.set_fin(false);
+
+  scoped_ptr<SpdySerializedFrame> frame(
+      spdy_framer_.SerializeFrame(push_promise));
+  WriteOrBufferData(StringPiece(frame->data(), frame->size()), false,
+                    ack_listener);
+  return frame->size();
+}
+
 void QuicHeadersStream::OnDataAvailable() {
   char buffer[1024];
   struct iovec iov;
   QuicTime timestamp(QuicTime::Zero());
   while (true) {
     iov.iov_base = buffer;
     iov.iov_len = arraysize(buffer);
     if (measure_headers_hol_blocking_time_) {
       if (!sequencer()->GetReadableRegion(&iov, &timestamp)) {
         // No more data to read.
         break;
       }
       DCHECK(timestamp.IsInitialized());
       cur_max_timestamp_ = QuicTime::Max(timestamp, cur_max_timestamp_);
     } else {
       if (sequencer()->GetReadableRegions(&iov, 1) != 1) {
         // No more data to read.
         break;
       }
     }
     if (spdy_framer_.ProcessInput(static_cast<char*>(iov.iov_base),
                                   iov.iov_len) != iov.iov_len) {
       // Error processing data.
       return;
     }
     sequencer()->MarkConsumed(iov.iov_len);
   }
 }
 
-QuicPriority QuicHeadersStream::EffectivePriority() const { return 0; }
+SpdyPriority QuicHeadersStream::Priority() const {
+  return net::kHighestPriority;  // The smallest priority is also the highest
+}
 
 void QuicHeadersStream::OnSynStream(SpdyStreamId stream_id,
                                     SpdyPriority priority,
                                     bool fin) {
   if (session()->perspective() == Perspective::IS_CLIENT) {
     CloseConnectionWithDetails(
         QUIC_INVALID_HEADERS_STREAM_DATA,
         "SPDY SYN_STREAM frame received at the client");
     return;
   }
@@ skipping 49 matching lines @@
 
 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
   frame_len_ += frame_len;
 }
 
 bool QuicHeadersStream::IsConnected() {
   return session()->connection()->connected();
 }
 
 }  // namespace net