Remove SpdyFramerVisitorInterface::OnControlFrameHeaderData().

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 <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 
 namespace net {
 
 namespace {
 
 // GOAWAY frame debug data is only buffered up to this many bytes.
 size_t kGoAwayDebugDataMaxSize = 1024;
 
-// Initial and maximum sizes for header block buffer.
-size_t kHeaderBufferInitialSize = 8 * 1024;
-size_t kHeaderBufferMaxSize = 256 * 1024;
-
 }  // namespace
 
 BufferedSpdyFramer::BufferedSpdyFramer()
     : spdy_framer_(HTTP2),
       visitor_(NULL),
       header_buffer_valid_(false),
       header_stream_id_(SpdyFramer::kInvalidStream),
       frames_received_(0) {}
 
 BufferedSpdyFramer::~BufferedSpdyFramer() {
@@ skipping 44 matching lines @@
   control_frame_fields_->fin = fin;
 
   InitHeaderStreaming(stream_id);
 }
 
 void BufferedSpdyFramer::OnSynReply(SpdyStreamId stream_id,
                                     bool fin) {
   NOTREACHED();
 }
 
-bool BufferedSpdyFramer::OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                                  const char* header_data,
-                                                  size_t len) {
-  CHECK_EQ(header_stream_id_, stream_id);
-
-  if (len == 0) {
-    // Indicates end-of-header-block.
-    CHECK(header_buffer_valid_);
-
-    SpdyHeaderBlock headers;
-    if (!spdy_framer_.ParseHeaderBlockInBuffer(
-            header_buffer_.data(), header_buffer_.size(), &headers)) {
-      visitor_->OnStreamError(
-          stream_id, "Could not parse Spdy Control Frame Header.");
-      return false;
-    }
-    DCHECK(control_frame_fields_.get());
-    switch (control_frame_fields_->type) {
-      case SYN_STREAM:
-        NOTREACHED();
-        break;
-      case SYN_REPLY:
-        NOTREACHED();
-        break;
-      case HEADERS:
-        visitor_->OnHeaders(control_frame_fields_->stream_id,
-                            control_frame_fields_->has_priority,
-                            control_frame_fields_->weight,
-                            control_frame_fields_->parent_stream_id,
-                            control_frame_fields_->exclusive,
-                            control_frame_fields_->fin, std::move(headers));
-        break;
-      case PUSH_PROMISE:
-        visitor_->OnPushPromise(control_frame_fields_->stream_id,
-                                control_frame_fields_->promised_stream_id,
-                                std::move(headers));
-        break;
-      default:
-        DCHECK(false) << "Unexpect control frame type: "
-                      << control_frame_fields_->type;
-        break;
-    }
-    control_frame_fields_.reset(NULL);
-    return true;
-  }
-
-  const size_t new_size = header_buffer_.size() + len;
-  if (new_size > kHeaderBufferMaxSize) {
-    header_buffer_valid_ = false;
-    visitor_->OnStreamError(stream_id, "Received too much header data.");
-    return false;
-  }
-
-  if (new_size > header_buffer_.capacity()) {
-    // Grow |header_buffer_| exponentially to reduce memory allocations and
-    // copies.
-    size_t new_capacity = std::max(new_size, kHeaderBufferInitialSize);
-    new_capacity = std::max(new_capacity, 2 * header_buffer_.capacity());
-    new_capacity = std::min(new_capacity, kHeaderBufferMaxSize);
-    header_buffer_.reserve(new_capacity);
-  }
-  header_buffer_.append(header_data, len);
-  return true;
-}
-
 void BufferedSpdyFramer::OnDataFrameHeader(SpdyStreamId stream_id,
                                            size_t length,
                                            bool fin) {
   frames_received_++;
   header_stream_id_ = stream_id;
   visitor_->OnDataFrameHeader(stream_id, length, fin);
 }
 
 void BufferedSpdyFramer::OnStreamFrameData(SpdyStreamId stream_id,
                                            const char* data,
@@ skipping 256 matching lines @@
 }
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   header_buffer_.clear();
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net