Improve NetLog logging in net::BidirectionalStream

net/http/bidirectional_stream.cc

 // Copyright 2015 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/http/bidirectional_stream.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 195 matching lines @@
 
 int64_t BidirectionalStream::GetTotalSentBytes() const {
   if (!stream_impl_)
     return 0;
 
   return stream_impl_->GetTotalSentBytes();
 }
 
 void BidirectionalStream::OnStreamReady(bool request_headers_sent) {
   request_headers_sent_ = request_headers_sent;
+  if (net_log_.IsCapturing()) {
+    net_log_.AddEvent(
+        NetLog::TYPE_BIDIRECTIONAL_STREAM_READY,
+        NetLog::BoolCallback("request_headers_sent", request_headers_sent));
+  }
   delegate_->OnStreamReady(request_headers_sent);
 }
 
 void BidirectionalStream::OnHeadersReceived(
     const SpdyHeaderBlock& response_headers) {
   HttpResponseInfo response_info;
   if (!SpdyHeadersToHttpResponse(response_headers, HTTP2, &response_info)) {
     DLOG(WARNING) << "Invalid headers";
     NotifyFailed(ERR_FAILED);
     return;
@@ skipping 18 matching lines @@
   }
   read_buffer_ = nullptr;
   delegate_->OnDataRead(bytes_read);
 }
 
 void BidirectionalStream::OnDataSent() {
   DCHECK(!write_buffer_list_.empty());
   DCHECK_EQ(write_buffer_list_.size(), write_buffer_len_list_.size());
 
   if (net_log_.IsCapturing()) {
+    if (write_buffer_list_.size() > 1) {
+      net_log_.BeginEvent(
+          NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
+          NetLog::IntCallback("num_buffers_coalesced",
+                              write_buffer_list_.size()));
+    }
     for (size_t i = 0; i < write_buffer_list_.size(); ++i) {
       net_log_.AddByteTransferEvent(
           NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
           write_buffer_len_list_[i], write_buffer_list_[i]->data());
     }
+    if (write_buffer_list_.size() > 1) {
+      net_log_.EndEvent(NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED);
+    }
   }
   write_buffer_list_.clear();
   write_buffer_len_list_.clear();
   delegate_->OnDataSent();
 }
 
 void BidirectionalStream::OnTrailersReceived(const SpdyHeaderBlock& trailers) {
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(NetLog::TYPE_BIDIRECTIONAL_STREAM_RECV_TRAILERS,
                       base::Bind(&NetLogHeadersCallback, &trailers));
   }
   delegate_->OnTrailersReceived(trailers);
 }
 
 void BidirectionalStream::OnFailed(int status) {
+  if (net_log_.IsCapturing()) {
+    net_log_.AddEvent(NetLog::TYPE_BIDIRECTIONAL_STREAM_FAILED,
+                      NetLog::IntCallback("net_error", status));
+  }
   NotifyFailed(status);
 }
 
 void BidirectionalStream::OnStreamReady(const SSLConfig& used_ssl_config,
                                         const ProxyInfo& used_proxy_info,
                                         HttpStream* stream) {
   NOTREACHED();
 }
 
 void BidirectionalStream::OnBidirectionalStreamImplReady(
@@ skipping 63 matching lines @@
   NotifyFailed(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
 }
 
 void BidirectionalStream::OnQuicBroken() {}
 
 void BidirectionalStream::NotifyFailed(int error) {
   delegate_->OnFailed(error);
 }
 
 }  // namespace net