Remove enum SpdyMajorVersion.

net/quic/core/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/core/quic_headers_stream.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_header_list.h"
 #include "net/quic/core/quic_server_session_base.h"
 #include "net/quic/core/quic_spdy_session.h"
 #include "net/quic/core/quic_time.h"
 #include "net/spdy/spdy_protocol.h"
 
 using base::StringPiece;
-using net::HTTP2;
 using net::SpdyFrameType;
 using std::string;
 
 namespace net {
 
 namespace {
 
 class HeaderTableDebugVisitor : public HpackHeaderTable::DebugVisitorInterface {
  public:
   HeaderTableDebugVisitor(
@@ skipping 257 matching lines @@
     }
   }
 
   void set_max_uncompressed_header_bytes(
       size_t set_max_uncompressed_header_bytes) {
     header_list_.set_max_uncompressed_header_bytes(
         set_max_uncompressed_header_bytes);
   }
 
  private:
-  void CloseConnection(const std::string& details) {
+  void CloseConnection(const string& details) {

[Bence, 2016/12/01 18:32:08]

This is a driveby change.

     if (stream_->IsConnected()) {
       stream_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                           details);
     }
   }
 
  private:
   QuicHeadersStream* stream_;
   QuicHeaderList header_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 };
 
 QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
     : QuicStream(kHeadersStreamId, session),
       spdy_session_(session),
       stream_id_(kInvalidStreamId),
       promised_stream_id_(kInvalidStreamId),
       fin_(false),
       frame_len_(0),
       uncompressed_frame_len_(0),
       supports_push_promise_(session->perspective() == Perspective::IS_CLIENT),
       cur_max_timestamp_(QuicTime::Zero()),
       prev_max_timestamp_(QuicTime::Zero()),
-      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,
@@ skipping 32 matching lines @@
   WriteOrBufferData(StringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
 QuicConsumedData QuicHeadersStream::WritevStreamData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
-  const size_t max_len = kSpdyInitialFrameSizeLimit -
-                         SpdyConstants::GetDataFrameMinimumSize(HTTP2);
+  const size_t max_len =
+      kSpdyInitialFrameSizeLimit - SpdyConstants::kDataFrameMinimumSize;
 
   QuicConsumedData result(0, false);
   size_t total_length = iov.total_length;
 
   // Encapsulate the data into HTTP/2 DATA frames.  The outer loop
   // handles each element of the source iov, the inner loop handles
   // the possibility of fragmenting eacho of those into multiple DATA
   // frames, as the DATA frames have a max size of 16KB.
   for (int i = 0; i < iov.iov_count; i++) {
     size_t offset = 0;
@@ skipping 200 matching lines @@
     return true;
   }
   frame_len_ -= len;
   // Ignore fin_ while there is more data coming, if frame_len_ > 0.
   spdy_session_->OnStreamFrameData(stream_id, data, len,
                                    frame_len_ > 0 ? false : fin_);
   return true;
 }
 
 }  // namespace net