Revert of Avoids the "re-encode HPACK as SPDY3" step.

net/spdy/spdy_framer_test.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/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 42 matching lines @@
  public:
   // Decompress a single frame using the decompression context held by
   // the SpdyFramer.  The implemention is meant for use only in tests
   // and will CHECK fail if the input is anything other than a single,
   // well-formed compressed frame.
   //
   // Returns a new decompressed SpdySerializedFrame.
   template <class SpdyFrameType>
   static SpdySerializedFrame DecompressFrame(SpdyFramer* framer,
                                              const SpdyFrameType& frame) {
-    NewDecompressionVisitor visitor;
+    DecompressionVisitor visitor(framer->protocol_version());
     framer->set_visitor(&visitor);
     CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
     CHECK_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer->state());
-    framer->set_visitor(nullptr);
-    SpdyFramer serializer(framer->protocol_version());
-    serializer.set_enable_compression(false);
-    return serializer.SerializeFrame(visitor.GetFrame());
+    framer->set_visitor(NULL);
+
+    char* buffer = visitor.ReleaseBuffer();
+    CHECK(buffer != NULL);
+    SpdySerializedFrame decompressed_frame(buffer, visitor.size(), true);
+    SetFrameLength(&decompressed_frame,
+                   visitor.size() - framer->GetControlFrameHeaderSize(),
+                   framer->protocol_version());
+    return decompressed_frame;
   }
 
-  class NewDecompressionVisitor : public SpdyFramerVisitorInterface {
+  class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
-    NewDecompressionVisitor() : finished_(false) {}
+    explicit DecompressionVisitor(SpdyMajorVersion version)
+        : version_(version), size_(0), finished_(false) {}
 
-    const SpdyFrameIR& GetFrame() const {
-      CHECK(finished_);
-      return *frame_;
+    void ResetBuffer() {
+      CHECK(buffer_.get() == NULL);
+      CHECK_EQ(0u, size_);
+      CHECK(!finished_);
+      buffer_.reset(new char[kMaxDecompressedSize]);
     }
 
-    SpdyHeadersHandlerInterface* OnHeaderFrameStart(
-        SpdyStreamId stream_id) override {
-      if (headers_handler_ == nullptr) {
-        headers_handler_.reset(new TestHeadersHandler);
-      }
-      return headers_handler_.get();
-    }
-
-    void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
-      CHECK(!finished_);
-      frame_->set_header_block(headers_handler_->decoded_block());
-      finished_ = true;
-      if (end_headers) {
-        headers_handler_.reset();
-      }
-    }
-
-    void OnSynStream(SpdyStreamId stream_id,
-                     SpdyStreamId associated_stream_id,
-                     SpdyPriority priority,
-                     bool fin,
-                     bool unidirectional) override {
-      SpdySynStreamIR* syn_stream = new SpdySynStreamIR(stream_id);
-      syn_stream->set_associated_to_stream_id(associated_stream_id);
-      syn_stream->set_priority(priority);
-      syn_stream->set_fin(fin);
-      syn_stream->set_unidirectional(unidirectional);
-      frame_.reset(syn_stream);
-    }
-
-    void OnSynReply(SpdyStreamId stream_id, bool fin) override {
-      SpdyHeadersIR* headers = new SpdyHeadersIR(stream_id);
-      headers->set_fin(fin);
-      frame_.reset(headers);
-    }
-
-    void OnHeaders(SpdyStreamId stream_id,
-                   bool has_priority,
-                   SpdyPriority priority,
-                   SpdyStreamId parent_stream_id,
-                   bool exclusive,
-                   bool fin,
-                   bool end) override {
-      SpdyHeadersIR* headers = new SpdyHeadersIR(stream_id);
-      headers->set_has_priority(has_priority);
-      headers->set_priority(priority);
-      headers->set_parent_stream_id(parent_stream_id);
-      headers->set_exclusive(exclusive);
-      headers->set_fin(fin);
-      frame_.reset(headers);
-    }
-
-    void OnPushPromise(SpdyStreamId stream_id,
-                       SpdyStreamId promised_stream_id,
-                       bool end) override {
-      SpdyPushPromiseIR* push_promise =
-          new SpdyPushPromiseIR(stream_id, promised_stream_id);
-      frame_.reset(push_promise);
-    }
-
-    // TODO(birenroy): Add support for CONTINUATION.
-    void OnContinuation(SpdyStreamId stream_id, bool end) override {
-      LOG(FATAL);
-    }
-
-    // All other methods just LOG(FATAL).
     void OnError(SpdyFramer* framer) override { LOG(FATAL); }
     void OnDataFrameHeader(SpdyStreamId stream_id,
                            size_t length,
                            bool fin) override {
       LOG(FATAL) << "Unexpected data frame header";
     }
     void OnStreamFrameData(SpdyStreamId stream_id,
                            const char* data,
                            size_t len) override {
       LOG(FATAL);
     }
 
     void OnStreamEnd(SpdyStreamId stream_id) override { LOG(FATAL); }
 
     void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
       LOG(FATAL);
     }
 
-    bool OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                  const char* header_data,
-                                  size_t len) override {
-      LOG(FATAL);
-      return true;
-    }
-
-    void OnRstStream(SpdyStreamId stream_id,
-                     SpdyRstStreamStatus status) override {
-      LOG(FATAL);
-    }
-    void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override {
-      LOG(FATAL);
-    }
-    void OnPing(SpdyPingId unique_id, bool is_ack) override { LOG(FATAL); }
-    void OnSettingsEnd() override { LOG(FATAL); }
-    void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                  SpdyGoAwayStatus status) override {
-      LOG(FATAL);
-    }
-
-    void OnWindowUpdate(SpdyStreamId stream_id,
-                        int delta_window_size) override {
-      LOG(FATAL);
-    }
-
-    void OnPriority(SpdyStreamId stream_id,
-                    SpdyStreamId parent_stream_id,
-                    uint8_t weight,
-                    bool exclusive) override {
-      // Do nothing.
-    }
-
-    bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
-      LOG(FATAL);
-      return false;
-    }
-
-   private:
-    std::unique_ptr<TestHeadersHandler> headers_handler_;
-    std::unique_ptr<SpdyFrameWithHeaderBlockIR> frame_;
-    bool finished_;
-
-    DISALLOW_COPY_AND_ASSIGN(NewDecompressionVisitor);
-  };
-
-  class DecompressionVisitor : public SpdyFramerVisitorInterface {
-   public:
-    explicit DecompressionVisitor(SpdyMajorVersion version)
-        : version_(version), size_(0), finished_(false) {}
-
-    void ResetBuffer() {
-      CHECK(buffer_.get() == NULL);
-      CHECK_EQ(0u, size_);
-      CHECK(!finished_);
-      buffer_.reset(new char[kMaxDecompressedSize]);
-    }
-
-    void OnError(SpdyFramer* framer) override { LOG(FATAL); }
-    void OnDataFrameHeader(SpdyStreamId stream_id,
-                           size_t length,
-                           bool fin) override {
-      LOG(FATAL) << "Unexpected data frame header";
-    }
-    void OnStreamFrameData(SpdyStreamId stream_id,
-                           const char* data,
-                           size_t len) override {
-      LOG(FATAL);
-    }
-
-    void OnStreamEnd(SpdyStreamId stream_id) override { LOG(FATAL); }
-
-    void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
-      LOG(FATAL);
-    }
-
     SpdyHeadersHandlerInterface* OnHeaderFrameStart(
         SpdyStreamId stream_id) override {
-      LOG(FATAL) << "Not implemented.";
+      LOG(FATAL);
       return nullptr;
     }
 
     void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
-      LOG(FATAL) << "Not implemented.";
+      LOG(FATAL);
     }
 
     bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                   const char* header_data,
                                   size_t len) override {
       CHECK(buffer_.get() != NULL);
       CHECK_GE(kMaxDecompressedSize, size_ + len);
       CHECK(!finished_);
       if (len != 0) {
         memcpy(buffer_.get() + size_, header_data, len);
@@ skipping 107 matching lines @@
       return buffer_.release();
     }
 
     size_t size() const {
       CHECK(finished_);
       return size_;
     }
 
    private:
     SpdyMajorVersion version_;
-    TestHeadersHandler* headers_handler_;
     std::unique_ptr<char[]> buffer_;
     size_t size_;
     bool finished_;
 
     DISALLOW_COPY_AND_ASSIGN(DecompressionVisitor);
   };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
 };
 
-class SpdyFramerPeer {
- public:
-  static size_t ControlFrameBufferSize() {
-    return SpdyFramer::kControlFrameBufferSize;
-  }
-  static size_t GetNumberRequiredContinuationFrames(SpdyFramer* framer,
-                                                    size_t size) {
-    return framer->GetNumberRequiredContinuationFrames(size);
-  }
-  static void SetError(SpdyFramer* framer, SpdyFramer::SpdyError error) {
-    framer->set_error(error);
-  }
-};
-
 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
                         public SpdyFramerDebugVisitorInterface {
  public:
   // This is larger than our max frame size because header blocks that
   // are too long can spill over into CONTINUATION frames.
   static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
 
   explicit TestSpdyVisitor(SpdyMajorVersion version)
       : framer_(version),
         use_compression_(false),
@@ skipping 64 matching lines @@
   }
 
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
     VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n";
     EXPECT_EQ(header_stream_id_, stream_id);
     data_bytes_ += len;
   }
 
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override {
-    if (headers_handler_ == nullptr) {
-      headers_handler_.reset(new TestHeadersHandler);
-    }
-    return headers_handler_.get();
+    LOG(FATAL) << "OnHeaderFrameStart(" << stream_id << ")";
+    return nullptr;
   }
 
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
-    CHECK(headers_handler_ != nullptr);
-    headers_ = headers_handler_->decoded_block();
-    header_bytes_received_ = headers_handler_->header_bytes_parsed();
-    if (end_headers) {
-      headers_handler_.reset();
-    }
+    LOG(FATAL) << "OnHeaderFrameEnd(" << stream_id << ", " << end_headers
+               << ")";
   }
 
   bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                 const char* header_data,
                                 size_t len) override {
     VLOG(1) << "OnControlFrameHeaderData(" << stream_id << ", data, " << len
             << ")";
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
@@ skipping 269 matching lines @@
   // The count of zero-length control frame header data chunks received.
   int zero_length_control_frame_header_data_count_;
   int data_frame_count_;
   size_t last_payload_len_;
   size_t last_frame_len_;
 
   // Header block streaming state:
   std::unique_ptr<char[]> header_buffer_;
   size_t header_buffer_length_;
   size_t header_buffer_size_;
-  size_t header_bytes_received_;
   SpdyStreamId header_stream_id_;
   SpdyFrameType header_control_type_;
   bool header_buffer_valid_;
-  std::unique_ptr<TestHeadersHandler> headers_handler_;
   SpdyHeaderBlock headers_;
   bool header_has_priority_;
   SpdyStreamId header_parent_stream_id_;
   bool header_exclusive_;
 };
 
+class SpdyFramerPeer {
+ public:
+  static size_t ControlFrameBufferSize() {
+    return SpdyFramer::kControlFrameBufferSize;
+  }
+  static size_t GetNumberRequiredContinuationFrames(SpdyFramer* framer,
+                                                    size_t size) {
+    return framer->GetNumberRequiredContinuationFrames(size);
+  }
+};
+
 // Retrieves serialized headers from a HEADERS or SYN_STREAM frame.
 StringPiece GetSerializedHeaders(const SpdySerializedFrame& frame,
                                  const SpdyFramer& framer) {
   SpdyFrameReader reader(frame.data(), frame.size());
   if (framer.protocol_version() == SPDY3) {
     reader.Seek(2);  // Seek past the frame length.
   } else {
     reader.Seek(3);  // Seek past the frame length.
   }
   SpdyFrameType frame_type;
@@ skipping 77 matching lines @@
   headers.set_priority(1);
   headers.SetHeader("cookie",
                     "=; key=value; ;  = ; foo; bar=;  ;  =   ; k2=v2 ; =");
   SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
 
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_NE(headers.header_block(), visitor.headers_);
   EXPECT_EQ(1u, visitor.headers_.size());
   EXPECT_EQ("key=value; foo; bar=; k2=v2 ", visitor.headers_["cookie"]);
 }
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
 
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(headers.header_block(), visitor.headers_);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
@@ skipping 142 matching lines @@
       0x08,                    // Flags (PADDED)
       0x00, 0x00, 0x00, 0x01,  // Stream id
       0xFF,                    // Padding length (here larger than length)
       0x00, 0x00, 0x00, 0x00,  // Arbitrary data payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
-  EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length not larger
 // than the payload length, we do not set an error of SPDY_INVALID_PADDING
 TEST_P(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
@@ skipping 11 matching lines @@
       0x01,                    // Type (HEADERS)
       0x08,                    // Flags (PADDED)
       0x00, 0x00, 0x00, 0x01,  // Stream id
       0x04,                    // Padding length
       0x00, 0x00, 0x00, 0x00,  // Padding
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
-  EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
+
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a SYN_REPLY with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, SynReplyWithStreamIdZero) {
   if (!IsSpdy3()) {
@@ skipping 2524 matching lines @@
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = headers_ir.header_block();
   SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
-  EXPECT_EQ(0, visitor.control_frame_header_data_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  // control_frame_header_data_count_ depends on the random sequence
+  // produced by rand(), so adding, removing or running single tests
+  // alters this value.  The best we can do is assert that it happens
+  // at least twice.
+  EXPECT_LE(2, visitor.control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = headers_ir.header_block();
   SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
-  EXPECT_EQ(0, visitor.control_frame_header_data_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  // control_frame_header_data_count_ depends on the random sequence
+  // produced by rand(), so adding, removing or running single tests
+  // alters this value.  The best we can do is assert that it happens
+  // at least twice.
+  EXPECT_LE(2, visitor.control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameAtMaxSizeLimit) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
 
@@ skipping 15 matching lines @@
   EXPECT_EQ(TestSpdyVisitor::sent_control_frame_max_size(),
             control_frame.size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
+  EXPECT_LT(kBigValueSize, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameTooLarge) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
 
   // First find the size of the header value in order to just reach the control
   // frame max size.
@@ skipping 54 matching lines @@
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 }
 
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
   string big_value(kBigValueSize, 'x');
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(framer.SerializeHeaders(headers));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
-  // It's up to the visitor to ignore extraneous header data; the framer
-  // won't throw an error.
-  EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_);
-  EXPECT_EQ(1, visitor.end_of_stream_count_);
+  EXPECT_FALSE(visitor.header_buffer_valid_);
+  EXPECT_EQ(1, visitor.error_count_);
+  EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
+            visitor.framer_.error_code())
+      << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
+
+  // The framer should have stoped delivering chunks after the visitor
+  // signaled "stop" by returning false from OnControlFrameHeaderData().
+  //
+  // control_frame_header_data_count_ depends on the random sequence
+  // produced by rand(), so adding, removing or running single tests
+  // alters this value.  The best we can do is assert that it happens
+  // at least kHeaderBufferChunks + 1.
+  EXPECT_LE(kHeaderBufferChunks + 1,
+            static_cast<unsigned>(visitor.control_frame_header_data_count_));
+  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+
+  // The framer should not have sent half-close to the visitor.
+  EXPECT_EQ(0, visitor.end_of_stream_count_);
 }
 
 TEST_P(SpdyFramerTest, DecompressCorruptHeaderBlock) {
   if (!IsSpdy3()) {
     // Deflate compression doesn't apply to HPACK.
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
@@ skipping 433 matching lines @@
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(
                   testing::Pair("cookie", "foo=bar; baz=bing; "),
                   testing::Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
   if (!IsHttp2()) {
@@ skipping 29 matching lines @@
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_push_promise_stream_);
   EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(2, visitor.continuation_count_);
-  EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
+  EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(
                   testing::Pair("cookie", "foo=bar; baz=bing; "),
                   testing::Pair("name", "value")));
 }
 
 // Receiving an unknown frame when a continuation is expected should
 // result in a SPDY_UNEXPECTED_FRAME error
@@ skipping 586 matching lines @@
     syn_stream.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
     SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
       EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
                                        flags & CONTROL_FLAG_UNIDIRECTIONAL));
-      EXPECT_CALL(visitor, OnHeaderFrameStart(8)).Times(1);
-      EXPECT_CALL(visitor, OnHeaderFrameEnd(8, _)).Times(1);
+      EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
+          .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
       }
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
@@ skipping 25 matching lines @@
 
     SpdySynReplyIR syn_reply(37);
     syn_reply.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
     SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSynReply(37, flags & CONTROL_FLAG_FIN));
-      EXPECT_CALL(visitor, OnHeaderFrameStart(37)).Times(1);
-      EXPECT_CALL(visitor, OnHeaderFrameEnd(37, _)).Times(1);
+      EXPECT_CALL(visitor, OnControlFrameHeaderData(37, _, _))
+          .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       }
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
@@ skipping 177 matching lines @@
     bool fin = flags & CONTROL_FLAG_FIN;
     bool end = IsSpdy3() || (flags & HEADERS_FLAG_END_HEADERS);
     if (IsHttp2() && flags & HEADERS_FLAG_PRIORITY) {
       has_priority = true;
       priority = 3;
       parent_stream_id = 5;
       exclusive = true;
     }
     EXPECT_CALL(visitor, OnHeaders(stream_id, has_priority, priority,
                                    parent_stream_id, exclusive, fin, end));
-    EXPECT_CALL(visitor, OnHeaderFrameStart(57)).Times(1);
-    if (end) {
-      EXPECT_CALL(visitor, OnHeaderFrameEnd(57, _)).Times(1);
-    }
+    EXPECT_CALL(visitor, OnControlFrameHeaderData(57, _, _))
+        .WillRepeatedly(testing::Return(true));
     if (flags & DATA_FLAG_FIN &&
         (IsSpdy3() || flags & HEADERS_FLAG_END_HEADERS)) {
       EXPECT_CALL(visitor, OnStreamEnd(_));
     } else {
       // Do not close the stream if we are expecting a CONTINUATION frame.
       EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
@@ skipping 75 matching lines @@
     SpdyPushPromiseIR push_promise(client_id, promised_id);
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
     // and implement framing.
     SetFrameFlags(&frame, flags & ~HEADERS_FLAG_PADDED, spdy_version_);
 
     bool end = flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
     EXPECT_CALL(debug_visitor,
                 OnReceiveCompressedFrame(client_id, PUSH_PROMISE, _));
-    EXPECT_CALL(visitor,
-                OnPushPromise(client_id, promised_id,
-                              flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE));
-    EXPECT_CALL(visitor, OnHeaderFrameStart(client_id)).Times(1);
-    if (end) {
-      EXPECT_CALL(visitor, OnHeaderFrameEnd(client_id, _)).Times(1);
-    }
+    EXPECT_CALL(visitor, OnPushPromise(client_id, promised_id, end));
+    EXPECT_CALL(visitor, OnControlFrameHeaderData(client_id, _, _))
+        .WillRepeatedly(testing::Return(true));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
   if (!IsHttp2()) {
     return;
   }
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _));
     EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false));
-    EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1);
+    EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
+          .WillRepeatedly(testing::Return(true));
 
     SpdyHeadersIR headers_ir(42);
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame0(framer.SerializeHeaders(headers_ir));
     SetFrameFlags(&frame0, 0, spdy_version_);
 
     SpdyContinuationIR continuation(42);
     continuation.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
     SetFrameFlags(&frame, flags, spdy_version_);
 
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _));
     EXPECT_CALL(visitor, OnContinuation(42, flags & HEADERS_FLAG_END_HEADERS));
-    bool end = flags & HEADERS_FLAG_END_HEADERS;
-    if (end) {
-      EXPECT_CALL(visitor, OnHeaderFrameEnd(42, _)).Times(1);
-    }
+    EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
+        .WillRepeatedly(testing::Return(true));
 
     framer.ProcessInput(frame0.data(), frame0.size());
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
@@ skipping 16 matching lines @@
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
   // Adjust size to remove the header block.
   SetFrameLength(&frame, framer.GetSynStreamMinimumSize() -
                              framer.GetControlFrameHeaderSize(),
                  spdy_version_);
 
   EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(1, SYN_STREAM, _));
   EXPECT_CALL(visitor, OnSynStream(1, 0, 1, false, false));
-  EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
-  EXPECT_CALL(visitor, OnHeaderFrameEnd(1, _)).Times(1);
+  EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
 
   framer.ProcessInput(frame.data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32_t kId = 0x020304;
   const uint32_t kFlags = 0x01;
@@ skipping 581 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net