Add headers argument to BufferedSpdyFramerVisitorInterface::OnPushPromise

net/spdy/buffered_spdy_framer.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/spdy/buffered_spdy_framer.h"
 
 #include "base/logging.h"
 
 namespace net {
 
@@ skipping 121 matching lines @@
       case SYN_REPLY:
         visitor_->OnSynReply(control_frame_fields_->stream_id,
                              control_frame_fields_->fin,
                              headers);
         break;
       case HEADERS:
         visitor_->OnHeaders(control_frame_fields_->stream_id,
                             control_frame_fields_->fin,
                             headers);
         break;
+      case PUSH_PROMISE:
+        DCHECK_LT(SPDY3, protocol_version());
+        visitor_->OnPushPromise(control_frame_fields_->stream_id,
+                                control_frame_fields_->promised_stream_id,
+                                headers);
+        break;
       default:
         DCHECK(false) << "Unexpect control frame type: "
                       << control_frame_fields_->type;
         break;
     }
     control_frame_fields_.reset(NULL);
     return true;
   }
 
   const size_t available = kHeaderBufferSize - header_buffer_used_;
@@ skipping 55 matching lines @@
 }
 
 void BufferedSpdyFramer::OnWindowUpdate(SpdyStreamId stream_id,
                                         uint32 delta_window_size) {
   visitor_->OnWindowUpdate(stream_id, delta_window_size);
 }
 
 void BufferedSpdyFramer::OnPushPromise(SpdyStreamId stream_id,
                                        SpdyStreamId promised_stream_id,
                                        bool end) {
-  // TODO(jgraettinger): Deliver headers, similar to OnHeaders.
-  visitor_->OnPushPromise(stream_id, promised_stream_id);
+  DCHECK_LT(SPDY3, protocol_version());
+  frames_received_++;
+  DCHECK(!control_frame_fields_.get());
+  control_frame_fields_.reset(new ControlFrameFields());
+  control_frame_fields_->type = PUSH_PROMISE;
+  control_frame_fields_->stream_id = stream_id;
+  control_frame_fields_->promised_stream_id = promised_stream_id;
+
+  InitHeaderStreaming(stream_id);
 }
 
 void BufferedSpdyFramer::OnContinuation(SpdyStreamId stream_id, bool end) {
 }
 
 SpdyMajorVersion BufferedSpdyFramer::protocol_version() {
   return spdy_framer_.protocol_version();
 }
 
 size_t BufferedSpdyFramer::ProcessInput(const char* data, size_t len) {
@@ skipping 117 matching lines @@
 SpdyFrame* BufferedSpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                                const char* data,
                                                uint32 len,
                                                SpdyDataFlags flags) {
   SpdyDataIR data_ir(stream_id,
                      base::StringPiece(data, len));
   data_ir.set_fin((flags & DATA_FLAG_FIN) != 0);
   return spdy_framer_.SerializeData(data_ir);
 }
 
+// TODO(jgraettinger): Eliminate uses of this method (prefer SpdyPushPromiseIR).
+SpdyFrame* BufferedSpdyFramer::CreatePushPromise(
+    SpdyStreamId stream_id,
+    SpdyStreamId promised_stream_id,
+    const SpdyHeaderBlock* headers) {
+  SpdyPushPromiseIR push_promise_ir(stream_id, promised_stream_id);
+  push_promise_ir.set_name_value_block(*headers);
+  return spdy_framer_.SerializePushPromise(push_promise_ir);
+}
+
 SpdyPriority BufferedSpdyFramer::GetHighestPriority() const {
   return spdy_framer_.GetHighestPriority();
 }
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   memset(header_buffer_, 0, kHeaderBufferSize);
   header_buffer_used_ = 0;
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net