Deletes dead code.

net/quic/chromium/quic_chromium_client_stream.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/quic/chromium/quic_chromium_client_stream.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 20 matching lines @@
       headers_delivered_(false),
       session_(session),
       can_migrate_(true),
       weak_factory_(this) {}
 
 QuicChromiumClientStream::~QuicChromiumClientStream() {
   if (delegate_)
     delegate_->OnClose();
 }
 
-void QuicChromiumClientStream::OnStreamHeadersComplete(bool fin,
-                                                       size_t frame_len) {
-  QuicSpdyStream::OnStreamHeadersComplete(fin, frame_len);
-  if (decompressed_headers().empty() && !decompressed_trailers().empty()) {
-    DCHECK(trailers_decompressed());
-    // The delegate will read the trailers via a posted task.
-    NotifyDelegateOfHeadersCompleteLater(received_trailers().Clone(),
-                                         frame_len);
-  } else {
-    DCHECK(!headers_delivered_);
-    SpdyHeaderBlock headers;
-    SpdyFramer framer(HTTP2);
-    size_t headers_len = decompressed_headers().length();
-    const char* header_data = decompressed_headers().data();
-    if (!framer.ParseHeaderBlockInBuffer(header_data, headers_len, &headers)) {
-      DLOG(WARNING) << "Invalid headers";
-      Reset(QUIC_BAD_APPLICATION_PAYLOAD);
-      return;
-    }
-    MarkHeadersConsumed(headers_len);
-    session_->OnInitialHeadersComplete(id(), headers);
-
-    // The delegate will read the headers via a posted task.
-    NotifyDelegateOfHeadersCompleteLater(std::move(headers), frame_len);
-  }
-}
-
 void QuicChromiumClientStream::OnInitialHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
 
   SpdyHeaderBlock header_block;
   int64_t length = -1;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &length, &header_block)) {
     DLOG(ERROR) << "Failed to parse header list: " << header_list.DebugString();
@@ skipping 10 matching lines @@
 }
 
 void QuicChromiumClientStream::OnTrailingHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnTrailingHeadersComplete(fin, frame_len, header_list);
   NotifyDelegateOfHeadersCompleteLater(received_trailers().Clone(), frame_len);
 }
 
-void QuicChromiumClientStream::OnPromiseHeadersComplete(
-    QuicStreamId promised_id,
-    size_t frame_len) {
-  size_t headers_len = decompressed_headers().length();
-  SpdyHeaderBlock headers;
-  SpdyFramer framer(HTTP2);
-  if (!framer.ParseHeaderBlockInBuffer(decompressed_headers().data(),
-                                       headers_len, &headers)) {
-    DLOG(WARNING) << "Invalid headers";
-    Reset(QUIC_BAD_APPLICATION_PAYLOAD);
-    return;
-  }
-  MarkHeadersConsumed(headers_len);
-
-  session_->HandlePromised(id(), promised_id, headers);
-}
-
 void QuicChromiumClientStream::OnPromiseHeaderList(
     QuicStreamId promised_id,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   SpdyHeaderBlock promise_headers;
   int64_t content_length = -1;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &content_length,
                                          &promise_headers)) {
     DLOG(ERROR) << "Failed to parse header list: " << header_list.DebugString();
     ConsumeHeaderList();
@@ skipping 159 matching lines @@
       weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)), frame_len));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersComplete(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   if (!delegate_)
     return;
   // Only mark trailers consumed when we are about to notify delegate.
   if (headers_delivered_) {
-    MarkTrailersConsumed(decompressed_trailers().length());
     MarkTrailersConsumed();
     // Post an async task to notify delegate of the FIN flag.
     NotifyDelegateOfDataAvailableLater();
     net_log_.AddEvent(
         NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   } else {
     headers_delivered_ = true;
     net_log_.AddEvent(
         NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
@@ skipping 24 matching lines @@
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net