Enhance net internals/net log output for QUIC.

net/quic/quic_http_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_http_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 30 matching lines @@
 
 QuicHttpStream::~QuicHttpStream() {
   Close(false);
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   CHECK(stream_);
 
+  stream_net_log_ = stream_net_log;
   request_info_ = request_info;
 
   return OK;
 }
 
 int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   CHECK(stream_);
   CHECK(!request_body_stream_);
   CHECK(!response_info_);
   CHECK(!callback.is_null());
   CHECK(response);
 
   // Store the serialized request headers.
   if (use_spdy_) {
     SpdyHeaderBlock headers;
     CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                      &headers, 3, /*direct=*/true);
     size_t len = SpdyFramer::GetSerializedLength(3, &headers);
     SpdyFrameBuilder builder(len);
     SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
     scoped_ptr<SpdyFrame> frame(builder.take());
     request_ = std::string(frame->data(), len);
+    // Log the actual request with the URL Request's net log.
+    stream_net_log_.AddEvent(
+        NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
+    // Also log to the QuicSession's net log.
+    stream_->net_log().AddEvent(
+        NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   } else {
     std::string path = HttpUtil::PathForRequest(request_info_->url);
     std::string first_line = base::StringPrintf("%s %s HTTP/1.1\r\n",
                                                 request_info_->method.c_str(),
                                                 path.c_str());
     request_ = first_line + request_headers.ToString();
+    // Log the actual request with the URL Request's net log.
+    stream_net_log_.AddEvent(
+        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
+        base::Bind(&HttpRequestHeaders::NetLogCallback,
+                   base::Unretained(&request_headers),
+                   &first_line));
+    // Also log to the QuicSession's net log.
+    stream_->net_log().AddEvent(
+        NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
+        base::Bind(&HttpRequestHeaders::NetLogCallback,
+                   base::Unretained(&request_headers),
+                   &first_line));
   }
 
   // Store the request body.
   request_body_stream_ = request_info_->upload_data_stream;
   if (request_body_stream_ && (request_body_stream_->size() ||
                                request_body_stream_->is_chunked())) {
     // Use kMaxPacketSize as the buffer size, since the request
     // body data is written with this size at a time.
     // TODO(rch): use a smarter value since we can't write an entire
     // packet due to overhead.
@@ skipping 360 matching lines @@
     if (len == 0) {
       return ERR_IO_PENDING;
     }
 
     // Save the remaining received data.
     size_t delta = read_buf_len - len;
     if (delta > 0) {
       BufferResponseBody(read_buf_->data(), delta);
     }
 
+    // The URLRequest logs these headers, so only log to the QuicSession's
+    // net log.
+    stream_->net_log().AddEvent(
+        NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
+        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
+
     SpdyHeadersToHttpResponse(headers, 3, response_info_);
     // Put the peer's IP address and port into the response.
     IPEndPoint address = stream_->GetPeerAddress();
     response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
     response_info_->vary_data.Init(*request_info_, *response_info_->headers);
     response_headers_received_ = true;
 
     return OK;
   }
   int end_offset = HttpUtil::LocateEndOfHeaders(read_buf_->StartOfBuffer(),
                                                 read_buf_->offset(), 0);
 
   if (end_offset == -1) {
     return ERR_IO_PENDING;
   }
 
   if (!stream_)
     return ERR_UNEXPECTED;
 
   scoped_refptr<HttpResponseHeaders> headers = new HttpResponseHeaders(
       HttpUtil::AssembleRawHeaders(read_buf_->StartOfBuffer(), end_offset));
 
   // Put the peer's IP address and port into the response.
   IPEndPoint address = stream_->GetPeerAddress();
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
   response_info_->headers = headers;
   response_info_->vary_data.Init(*request_info_, *response_info_->headers);
   response_headers_received_ = true;
 
+  // The URLRequest logs these headers, so only log to the QuicSession's
+  // net log.
+  stream_->net_log().AddEvent(
+      NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
+      base::Bind(&HttpResponseHeaders::NetLogCallback,
+                 response_info_->headers));
+
   // Save the remaining received data.
   int delta = read_buf_->offset() - end_offset;
   if (delta > 0) {
     BufferResponseBody(read_buf_->data(), delta);
   }
 
   return OK;
 }
 
 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
   if (length == 0)
     return;
   IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
   memcpy(io_buffer->data(), data, length);
   response_body_.push_back(make_scoped_refptr(io_buffer));
 }
 
 }  // namespace net