Split QuicChromiumClientStreamDelegate::OnHeadersAvailable into

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 42 matching lines @@
     ConsumeHeaderList();
     Reset(QUIC_BAD_APPLICATION_PAYLOAD);
     return;
   }
 
   ConsumeHeaderList();
   session_->OnInitialHeadersComplete(id(), header_block);
 
   if (delegate_) {
     // The delegate will receive the headers via a posted task.
-    NotifyDelegateOfHeadersCompleteLater(std::move(header_block), frame_len);
+    NotifyDelegateOfInitialHeadersAvailableLater(std::move(header_block),
+                                                 frame_len);
     return;
   }
 
   // Buffer the headers and deliver them when the delegate arrives.
   initial_headers_ = std::move(header_block);
   initial_headers_frame_len_ = frame_len;
 }
 
 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);
+  NotifyDelegateOfTrailingHeadersAvailableLater(received_trailers().Clone(),
+                                                frame_len);
 }
 
 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)) {
@@ skipping 104 matching lines @@
 
 void QuicChromiumClientStream::SetDelegate(
     QuicChromiumClientStream::Delegate* delegate) {
   DCHECK(!(delegate_ && delegate));
   delegate_ = delegate;
   if (delegate == nullptr)
     return;
 
   // Should this perhaps be via PostTask to make reasoning simpler?
   if (!initial_headers_.empty()) {
-    delegate_->OnHeadersAvailable(std::move(initial_headers_),
-                                  initial_headers_frame_len_);
+    delegate_->OnInitialHeadersAvailable(std::move(initial_headers_),
+                                         initial_headers_frame_len_);
   }
 }
 
 void QuicChromiumClientStream::OnError(int error) {
   if (delegate_) {
     QuicChromiumClientStream::Delegate* delegate = delegate_;
     delegate_ = nullptr;
     delegate->OnError(error);
   }
 }
 
 int QuicChromiumClientStream::Read(IOBuffer* buf, int buf_len) {
   if (IsDoneReading())
     return 0;  // EOF
 
   if (!HasBytesToRead())
     return ERR_IO_PENDING;
 
   iovec iov;
   iov.iov_base = buf->data();
   iov.iov_len = buf_len;
   size_t bytes_read = Readv(&iov, 1);
   // Since HasBytesToRead is true, Readv() must of read some data.
   DCHECK_NE(0u, bytes_read);
   return bytes_read;
 }
 
-void QuicChromiumClientStream::NotifyDelegateOfHeadersCompleteLater(
+void QuicChromiumClientStream::NotifyDelegateOfInitialHeadersAvailableLater(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   DCHECK(delegate_);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
-                 weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)),
-                 frame_len));
+      base::Bind(
+          &QuicChromiumClientStream::NotifyDelegateOfInitialHeadersAvailable,
+          weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)),
+          frame_len));
 }
 
-void QuicChromiumClientStream::NotifyDelegateOfHeadersComplete(
+void QuicChromiumClientStream::NotifyDelegateOfInitialHeadersAvailable(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   if (!delegate_)
     return;
+
+  DCHECK(!headers_delivered_);
+  headers_delivered_ = true;
+  net_log_.AddEvent(
+      NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
+      base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
+
+  delegate_->OnInitialHeadersAvailable(headers, frame_len);
+}
+
+void QuicChromiumClientStream::NotifyDelegateOfTrailingHeadersAvailableLater(
+    SpdyHeaderBlock headers,
+    size_t frame_len) {
+  DCHECK(delegate_);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &QuicChromiumClientStream::NotifyDelegateOfTrailingHeadersAvailable,
+          weak_factory_.GetWeakPtr(), base::Passed(std::move(headers)),
+          frame_len));
+}
+
+void QuicChromiumClientStream::NotifyDelegateOfTrailingHeadersAvailable(
+    SpdyHeaderBlock headers,
+    size_t frame_len) {
+  if (!delegate_)
+    return;
+
+  DCHECK(headers_delivered_);
   // Only mark trailers consumed when we are about to notify delegate.
-  if (headers_delivered_) {
-    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,
-        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
-  }
+  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));
 
-  delegate_->OnHeadersAvailable(headers, frame_len);
+  delegate_->OnTrailingHeadersAvailable(headers, frame_len);
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailableLater() {
   DCHECK(delegate_);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&QuicChromiumClientStream::NotifyDelegateOfDataAvailable,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailable() {
   if (delegate_)
     delegate_->OnDataAvailable();
 }
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net