Log SPDY request headers in URL_REQUEST events in net-internals.

net/spdy/spdy_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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/stringprintf.h"
+#include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
+#include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
+namespace {
+
+Value* NetLogSpdySendRequestCallback(const SpdyHeaderBlock& headers,

[eroman, 2012/07/31 19:45:39]

IMPORTANT: Define this parameter as a |const SpdyHeaderBlock*|. The issue has to
do with how base::Bind() works -- if it is defined as a const reference,
base::Bind() infrastructure will create a copy of the header block which is
undesirable for our logging purposes.

[szym, 2012/07/31 22:49:34]

I believe that the same can be accomplished with base::ConstRef (defined in
bind_helpers.h). It implies that the argument must outlive the callback, which
is the case here, and might be more readable (style-compliant) than passing a
pointer.

[eroman, 2012/08/01 00:20:29]

Thanks for the info szym, I didn't know about that!

+                                     NetLog::LogLevel /* log_level */) {

[ramant (doing other things), 2012/07/31 19:48:57]

nit: +1 to eroman's comments. Was wondering why we didn't pass const
SpdyHeaderBlock* headers as it was done in  NetLogSpdySynCallback.

+  DictionaryValue* dict = new DictionaryValue();
+  ListValue* headers_list = new ListValue();
+  for (SpdyHeaderBlock::const_iterator it = headers.begin();
+       it != headers.end(); ++it) {
+    headers_list->Append(new StringValue(base::StringPrintf(
+        "%s: %s", it->first.c_str(), it->second.c_str())));
+  }
+  dict->Set("headers", headers_list);
+  return dict;
+}
+
+}  // namespace
+
 SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session,
                                bool direct)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       stream_(NULL),
       spdy_session_(spdy_session),
       response_info_(NULL),
       download_finished_(false),
       response_headers_received_(false),
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
@@ skipping 153 matching lines @@
                                 const CompletionCallback& callback) {
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetDelegate(this);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    headers.get(), stream_->GetProtocolVersion(),
                                    direct_);
+  stream_->net_log().AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
+      base::Bind(&NetLogSpdySendRequestCallback, *headers));
   stream_->set_spdy_headers(headers.Pass());
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
   CHECK(!request_body_stream_.get());
@@ skipping 316 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net