Remove SpdyFramerVisitorInterface::OnControlFrameHeaderData().

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"
@@ skipping 101 matching lines @@
                    SpdyPriority priority,
                    bool fin,
                    bool unidirectional) override {
     CloseConnection("SPDY SYN_STREAM frame received.");
   }
 
   void OnSynReply(SpdyStreamId stream_id, bool fin) override {
     CloseConnection("SPDY SYN_REPLY frame received.");
   }
 
-  bool OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                const char* header_data,
-                                size_t len) override {
-    if (!stream_->IsConnected()) {
-      return false;
-    }
-    stream_->OnControlFrameHeaderData(stream_id, header_data, len);
-    return true;
-  }
-
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len) override {
     if (stream_->OnStreamFrameData(stream_id, data, len)) {
       return;
     }
     CloseConnection("SPDY DATA frame received.");
   }
 
   void OnStreamEnd(SpdyStreamId stream_id) override {
@@ skipping 166 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 string& details) {
+  void CloseConnection(const std::string& details) {
     if (stream_->IsConnected()) {
       stream_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                           details);
     }
   }
 
  private:
   QuicHeadersStream* stream_;
   QuicHeaderList header_list_;
 
@@ skipping 169 matching lines @@
 
 void QuicHeadersStream::OnPushPromise(SpdyStreamId stream_id,
                                       SpdyStreamId promised_stream_id,
                                       bool end) {
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   DCHECK_EQ(kInvalidStreamId, promised_stream_id_);
   stream_id_ = stream_id;
   promised_stream_id_ = promised_stream_id;
 }
 
-void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                                 const char* header_data,
-                                                 size_t len) {
-  DCHECK_EQ(stream_id_, stream_id);
-  if (len == 0) {
-    DCHECK_NE(0u, stream_id_);
-    DCHECK_NE(0u, frame_len_);
-    if (prev_max_timestamp_ > cur_max_timestamp_) {
-      // prev_max_timestamp_ > cur_max_timestamp_ implies that
-      // headers from lower numbered streams actually came off the
-      // wire after headers for the current stream, hence there was
-      // HOL blocking.
-      QuicTime::Delta delta = prev_max_timestamp_ - cur_max_timestamp_;
-      DVLOG(1) << "stream " << stream_id
-               << ": Net.QuicSession.HeadersHOLBlockedTime "
-               << delta.ToMilliseconds();
-      spdy_session_->OnHeadersHeadOfLineBlocking(delta);
-    }
-    prev_max_timestamp_ = std::max(prev_max_timestamp_, cur_max_timestamp_);
-    cur_max_timestamp_ = QuicTime::Zero();
-    if (promised_stream_id_ == kInvalidStreamId) {
-      spdy_session_->OnStreamHeadersComplete(stream_id_, fin_, frame_len_);
-    } else {
-      spdy_session_->OnPromiseHeadersComplete(stream_id_, promised_stream_id_,
-                                              frame_len_);
-    }
-    if (uncompressed_frame_len_ != 0) {
-      int compression_pct = 100 - (100 * frame_len_) / uncompressed_frame_len_;
-      DVLOG(1) << "Net.QuicHpackDecompressionPercentage: " << compression_pct;
-      UMA_HISTOGRAM_PERCENTAGE("Net.QuicHpackDecompressionPercentage",
-                               compression_pct);
-    }
-    // Reset state for the next frame.
-    promised_stream_id_ = kInvalidStreamId;
-    stream_id_ = kInvalidStreamId;
-    fin_ = false;
-    frame_len_ = 0;
-    uncompressed_frame_len_ = 0;
-  } else {
-    uncompressed_frame_len_ += len;
-    if (promised_stream_id_ == kInvalidStreamId) {
-      spdy_session_->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
-    } else {
-      spdy_session_->OnPromiseHeaders(stream_id_,
-                                      StringPiece(header_data, len));
-    }
-  }
-}
-
 void QuicHeadersStream::OnHeaderList(const QuicHeaderList& header_list) {
   DVLOG(1) << "Received header list for stream " << stream_id_ << ": "
            << header_list.DebugString();
   if (prev_max_timestamp_ > cur_max_timestamp_) {
     // prev_max_timestamp_ > cur_max_timestamp_ implies that
     // headers from lower numbered streams actually came off the
     // wire after headers for the current stream, hence there was
     // HOL blocking.
     QuicTime::Delta delta = prev_max_timestamp_ - cur_max_timestamp_;
     DVLOG(1) << "stream " << stream_id_
@@ skipping 82 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