Improve NetLog logging in net::BidirectionalStream

net/http/bidirectional_stream_unittest.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 "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 579 matching lines @@
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 
   // Destroy the delegate will destroy the stream, so we can get an end event
   // for BIDIRECTIONAL_STREAM_ALIVE.
   delegate.reset();
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
+
   size_t index = ExpectLogContainsSomewhere(
       entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_ALIVE, NetLog::PHASE_BEGIN);
   // HTTP_STREAM_REQUEST is nested inside in BIDIRECTIONAL_STREAM_ALIVE.
   index = ExpectLogContainsSomewhere(
       entries, index, NetLog::TYPE_HTTP_STREAM_REQUEST, NetLog::PHASE_BEGIN);
   index = ExpectLogContainsSomewhere(
       entries, index, NetLog::TYPE_HTTP_STREAM_REQUEST, NetLog::PHASE_END);
   // Headers received should happen after HTTP_STREAM_REQUEST.
   index = ExpectLogContainsSomewhere(
       entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_RECV_HEADERS,
@@ skipping 192 matching lines @@
   EXPECT_EQ(1, delegate->on_data_read_count());
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
+
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+  size_t index = ExpectLogContainsSomewhere(
+      entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
+      NetLog::PHASE_BEGIN);
+  TestNetLogEntry entry = entries[index];
+  int num_buffers_coalesced = 0;
+  EXPECT_TRUE(entry.params->GetInteger("num_buffers_coalesced",
+                                       &num_buffers_coalesced));
+  EXPECT_EQ(2, num_buffers_coalesced);
+
+  index = ExpectLogContainsSomewhereAfter(
+      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
+      NetLog::PHASE_NONE);
+  entry = entries[index];
+  int byte_count = 0;
+  EXPECT_TRUE(entry.params->GetInteger("byte_count", &byte_count));
+  EXPECT_EQ(buf->size(), byte_count);
+
+  index = ExpectLogContainsSomewhereAfter(
+      entries, index + 1, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
+      NetLog::PHASE_NONE);
+  entry = entries[index];
+  byte_count = 0;
+  EXPECT_TRUE(entry.params->GetInteger("byte_count", &byte_count));
+  EXPECT_EQ(buf2->size(), byte_count);
+
+  ExpectLogContainsSomewhere(
+      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
+      NetLog::PHASE_END);
 }
 
 // Tests that BidirectionalStreamSpdyImpl::OnClose will complete any remaining
 // read even if the read queue is empty.
 TEST_F(BidirectionalStreamTest, TestCompleteAsyncRead) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   // Empty DATA frame with an END_STREAM flag.
   std::unique_ptr<SpdySerializedFrame> end_stream(
       spdy_util_.ConstructSpdyBodyFrame(1, nullptr, 0, true));
@@ skipping 396 matching lines @@
   EXPECT_EQ(delegate->response_headers().end(),
             delegate->response_headers().find(":status"));
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   // BidirectionalStreamSpdyStreamJob does not count the bytes sent for |rst|
   // because it is sent after SpdyStream::Delegate::OnClose is called.
   EXPECT_EQ(CountWriteBytes(writes, 1), delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
+
+  TestNetLogEntry::List entries;
+  net_log_.GetEntries(&entries);
+
+  size_t index = ExpectLogContainsSomewhere(
+      entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_READY, NetLog::PHASE_NONE);
+  TestNetLogEntry entry = entries[index];
+  bool request_headers_sent = false;
+  EXPECT_TRUE(
+      entry.params->GetBoolean("request_headers_sent", &request_headers_sent));
+  EXPECT_TRUE(request_headers_sent);
+
+  index = ExpectLogContainsSomewhere(entries, index,
+                                     NetLog::TYPE_BIDIRECTIONAL_STREAM_FAILED,
+                                     NetLog::PHASE_NONE);
+  entry = entries[index];
+  int net_error = OK;
+  EXPECT_TRUE(entry.params->GetInteger("net_error", &net_error));
+  EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, net_error);
 }
 
 INSTANTIATE_TEST_CASE_P(CancelOrDeleteTests,
                         BidirectionalStreamTest,
                         ::testing::Values(true, false));
 
 TEST_P(BidirectionalStreamTest, CancelOrDeleteStreamDuringOnHeadersReceived) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
 
@@ skipping 289 matching lines @@
   AlternativeServiceVector alternative_service_vector =
       http_session_->http_server_properties()->GetAlternativeServices(server);
   ASSERT_EQ(1u, alternative_service_vector.size());
   EXPECT_EQ(AlternateProtocolFromNextProto(kProtoQUIC1SPDY3),
             alternative_service_vector[0].protocol);
   EXPECT_EQ("www.example.org", alternative_service_vector[0].host);
   EXPECT_EQ(443, alternative_service_vector[0].port);
 }
 
 }  // namespace net