Add logging for headers sent and received in BidirectionalStreamQuicImpl

net/quic/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/quic_chromium_client_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_chromium_client_session.h"
+#include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 
 namespace net {
 
 QuicChromiumClientStream::QuicChromiumClientStream(
     QuicStreamId id,
     QuicClientSessionBase* session,
     const BoundNetLog& net_log)
@@ skipping 74 matching lines @@
 }
 
 void QuicChromiumClientStream::OnCanWrite() {
   ReliableQuicStream::OnCanWrite();
 
   if (!HasBufferedData() && !callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(OK);
   }
 }
 
+size_t QuicChromiumClientStream::WriteHeaders(
+    const SpdyHeaderBlock& header_block,
+    bool fin,
+    QuicAckListenerInterface* ack_notifier_delegate) {
+  // Log request headers to the QuicSession's net log.

[mmenke, 2016/03/23 20:32:21]

Think these comments are confusing - we're logging to the
QuicChromiumClientStream's BoundNetLog, which is called net_log_....Which does
use the same NetLog with the QuicSession, but that uses a different BoundNetLog.

I suggest just removing all 3 of them.

[xunjieli, 2016/03/23 22:19:23]

Done.

+  net_log_.AddEvent(
+      NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
+      base::Bind(&QuicRequestNetLogCallback, id(), &header_block,
+                 QuicSpdyStream::priority()));
+  return QuicSpdyStream::WriteHeaders(header_block, fin, ack_notifier_delegate);
+}
+
 SpdyPriority QuicChromiumClientStream::priority() const {
   if (delegate_ && delegate_->HasSendHeadersComplete()) {
     return QuicSpdyStream::priority();
   }
   return net::kV3HighestPriority;
 }
 
 int QuicChromiumClientStream::WriteStreamData(
     base::StringPiece data,
     bool fin,
@@ skipping 63 matching lines @@
       base::Bind(&QuicChromiumClientStream::NotifyDelegateOfHeadersComplete,
                  weak_factory_.GetWeakPtr(), 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_)
+  if (headers_delivered_) {
     MarkTrailersConsumed(decompressed_trailers().length());
+    // Log response trailers to the QuicSession's net log.
+    net_log_.AddEvent(
+        NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
+  } else {
+    headers_delivered_ = true;
+    // Log response headers to the QuicSession's net log.
+    net_log_.AddEvent(
+        NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
+  }
 
-  headers_delivered_ = true;
   delegate_->OnHeadersAvailable(headers, frame_len);
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailableLater() {
   RunOrBuffer(
       base::Bind(&QuicChromiumClientStream::NotifyDelegateOfDataAvailable,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfDataAvailable() {
   if (delegate_)
     delegate_->OnDataAvailable();
 }
 
 void QuicChromiumClientStream::RunOrBuffer(base::Closure closure) {
   if (delegate_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
   } else {
     delegate_tasks_.push_back(closure);
   }
 }
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 }  // namespace net