Remove many-many SpdyMajorVersion and NextProto arguments and members.

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 <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
 
-SpdyMajorVersion NextProtoToSpdyMajorVersion(NextProto next_proto) {
-  switch (next_proto) {
-    case kProtoSPDY31:
-      return SPDY3;
-    case kProtoHTTP2:
-      return HTTP2;
-    case kProtoUnknown:
-    case kProtoHTTP11:
-    case kProtoQUIC1SPDY3:
-      break;
-  }
-  NOTREACHED();
-  return HTTP2;
-}
-
-BufferedSpdyFramer::BufferedSpdyFramer(SpdyMajorVersion version)
-    : spdy_framer_(version),
+BufferedSpdyFramer::BufferedSpdyFramer()
+    : spdy_framer_(HTTP2),
       visitor_(NULL),
       header_buffer_valid_(false),
       header_stream_id_(SpdyFramer::kInvalidStream),
       frames_received_(0) {}
 
 BufferedSpdyFramer::~BufferedSpdyFramer() {
 }
 
 void BufferedSpdyFramer::set_visitor(
     BufferedSpdyFramerVisitorInterface* visitor) {
   visitor_ = visitor;
   spdy_framer_.set_visitor(this);
 }
 
 void BufferedSpdyFramer::set_debug_visitor(
     SpdyFramerDebugVisitorInterface* debug_visitor) {
   spdy_framer_.set_debug_visitor(debug_visitor);
 }
 
 void BufferedSpdyFramer::OnError(SpdyFramer* spdy_framer) {
   DCHECK(spdy_framer);
   visitor_->OnError(spdy_framer->error_code());
 }
 
 void BufferedSpdyFramer::OnSynStream(SpdyStreamId stream_id,
                                      SpdyStreamId associated_stream_id,
                                      SpdyPriority priority,
                                      bool fin,
                                      bool unidirectional) {
-  frames_received_++;
-  DCHECK(!control_frame_fields_.get());
-  control_frame_fields_.reset(new ControlFrameFields());
-  control_frame_fields_->type = SYN_STREAM;
-  control_frame_fields_->stream_id = stream_id;
-  control_frame_fields_->associated_stream_id = associated_stream_id;
-  control_frame_fields_->priority = priority;
-  control_frame_fields_->fin = fin;
-  control_frame_fields_->unidirectional = unidirectional;
-
-  InitHeaderStreaming(stream_id);
+  NOTREACHED();
 }
 
 void BufferedSpdyFramer::OnHeaders(SpdyStreamId stream_id,
                                    bool has_priority,
                                    int weight,
                                    SpdyStreamId parent_stream_id,
                                    bool exclusive,
                                    bool fin,
                                    bool end) {
   frames_received_++;
   DCHECK(!control_frame_fields_.get());
   control_frame_fields_.reset(new ControlFrameFields());
   control_frame_fields_->type = HEADERS;
   control_frame_fields_->stream_id = stream_id;
   control_frame_fields_->has_priority = has_priority;
   if (control_frame_fields_->has_priority) {
     control_frame_fields_->weight = weight;
     control_frame_fields_->parent_stream_id = parent_stream_id;
     control_frame_fields_->exclusive = exclusive;
   }
   control_frame_fields_->fin = fin;
 
   InitHeaderStreaming(stream_id);
 }
 
 void BufferedSpdyFramer::OnSynReply(SpdyStreamId stream_id,
                                     bool fin) {
-  frames_received_++;
-  DCHECK(!control_frame_fields_.get());
-  control_frame_fields_.reset(new ControlFrameFields());
-  control_frame_fields_->type = SYN_REPLY;
-  control_frame_fields_->stream_id = stream_id;
-  control_frame_fields_->fin = fin;
-
-  InitHeaderStreaming(stream_id);
+  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:
-        visitor_->OnSynStream(control_frame_fields_->stream_id,
-                              control_frame_fields_->associated_stream_id,
-                              control_frame_fields_->priority,
-                              control_frame_fields_->fin,
-                              control_frame_fields_->unidirectional,
-                              headers);
+        NOTREACHED();
         break;
       case SYN_REPLY:
-        visitor_->OnSynReply(control_frame_fields_->stream_id,
-                             control_frame_fields_->fin,
-                             headers);
+        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, 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);
@@ skipping 36 matching lines @@
 void BufferedSpdyFramer::OnStreamEnd(SpdyStreamId stream_id) {
   visitor_->OnStreamEnd(stream_id);
 }
 
 void BufferedSpdyFramer::OnStreamPadding(SpdyStreamId stream_id, size_t len) {
   visitor_->OnStreamPadding(stream_id, len);
 }
 
 SpdyHeadersHandlerInterface* BufferedSpdyFramer::OnHeaderFrameStart(
     SpdyStreamId stream_id) {
-  coalescer_.reset(new HeaderCoalescer(protocol_version()));
+  coalescer_.reset(new HeaderCoalescer());
   return coalescer_.get();
 }
 
 void BufferedSpdyFramer::OnHeaderFrameEnd(SpdyStreamId stream_id,
                                           bool end_headers) {
   if (coalescer_->error_seen()) {
     visitor_->OnStreamError(stream_id,
                             "Could not parse Spdy Control Frame Header.");
     return;
   }
   DCHECK(control_frame_fields_.get());
   switch (control_frame_fields_->type) {
     case SYN_STREAM:
-      visitor_->OnSynStream(
-          control_frame_fields_->stream_id,
-          control_frame_fields_->associated_stream_id,
-          control_frame_fields_->priority, control_frame_fields_->fin,
-          control_frame_fields_->unidirectional, coalescer_->headers());
+      NOTREACHED();
       break;
     case SYN_REPLY:
-      visitor_->OnSynReply(control_frame_fields_->stream_id,
-                           control_frame_fields_->fin, coalescer_->headers());
+      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, coalescer_->headers());
       break;
     case PUSH_PROMISE:
-      DCHECK_LT(SPDY3, protocol_version());
       visitor_->OnPushPromise(control_frame_fields_->stream_id,
                               control_frame_fields_->promised_stream_id,
                               coalescer_->headers());
       break;
     default:
       DCHECK(false) << "Unexpect control frame type: "
                     << control_frame_fields_->type;
       break;
   }
   control_frame_fields_.reset(NULL);
@@ skipping 50 matching lines @@
 }
 
 void BufferedSpdyFramer::OnWindowUpdate(SpdyStreamId stream_id,
                                         int delta_window_size) {
   visitor_->OnWindowUpdate(stream_id, delta_window_size);
 }
 
 void BufferedSpdyFramer::OnPushPromise(SpdyStreamId stream_id,
                                        SpdyStreamId promised_stream_id,
                                        bool end) {
-  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::OnAltSvc(
     SpdyStreamId stream_id,
     base::StringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   visitor_->OnAltSvc(stream_id, origin, altsvc_vector);
 }
 
 void BufferedSpdyFramer::OnContinuation(SpdyStreamId stream_id, bool end) {
 }
 
 bool BufferedSpdyFramer::OnUnknownFrame(SpdyStreamId stream_id,
                                         int frame_type) {
   return visitor_->OnUnknownFrame(stream_id, frame_type);
 }
 
-SpdyMajorVersion BufferedSpdyFramer::protocol_version() {
-  return spdy_framer_.protocol_version();
-}
-
 size_t BufferedSpdyFramer::ProcessInput(const char* data, size_t len) {
   return spdy_framer_.ProcessInput(data, len);
 }
 
 void BufferedSpdyFramer::Reset() {
   spdy_framer_.Reset();
 }
 
 SpdyFramer::SpdyError BufferedSpdyFramer::error_code() const {
   return spdy_framer_.error_code();
@@ skipping 132 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