Enhance net internals/net log output for QUIC.

net/quic/quic_client_session.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_client_session.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_stream_factory.h"
 #include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
+namespace {
+
+Value* NetLogQuicSessionCallback(const std::string& host,

[eroman, 2013/02/05 23:52:40]

Delete.

[Ryan Hamilton, 2013/02/06 16:40:15]

Whoops!  Done.  Sorry.

+                                 NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("host", host);
+  return dict;
+}
+
+Value* NetLogQuicSessionCloseOnErrorCallback(int error,

[eroman, 2013/02/05 23:52:40]

Delete.

[Ryan Hamilton, 2013/02/06 16:40:15]

Done.

+                                             NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetInteger("net_error", error);
+  return dict;
+}
+
+}  // namespace
+
 QuicClientSession::QuicClientSession(QuicConnection* connection,
                                      QuicConnectionHelper* helper,
                                      QuicStreamFactory* stream_factory,
-                                     const string& server_hostname)
+                                     const string& server_hostname,
+                                     NetLog* net_log)
     : QuicSession(connection, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(crypto_stream_(this, server_hostname)),
       helper_(helper),
       stream_factory_(stream_factory),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
-      read_pending_(false) {
+      read_pending_(false),
+      num_total_streams_(0),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)) {

[eroman, 2013/02/05 23:52:40]

the fact that it is QUIC and not QUICK keeps blowing up my head

[Ryan Hamilton, 2013/02/06 16:40:15]

:>

+  // TODO(rch): pass in full host port proxy pair
+  net_log_.BeginEvent(
+      NetLog::TYPE_QUIC_SESSION,
+      NetLog::StringCallback("host", &server_hostname));
 }
 
 QuicClientSession::~QuicClientSession() {
+  net_log_.EndEvent(NetLog::TYPE_QUIC_SESSION);
 }
 
 QuicReliableClientStream* QuicClientSession::CreateOutgoingReliableStream() {
   if (!crypto_stream_.handshake_complete()) {
     DLOG(INFO) << "Crypto handshake not complete, no outgoing stream created.";
     return NULL;
   }
   if (GetNumOpenStreams() >= get_max_open_streams()) {
     DLOG(INFO) << "Failed to create a new outgoing stream. "
                << "Already " << GetNumOpenStreams() << " open.";
     return NULL;
   }
   QuicReliableClientStream* stream =
-       new QuicReliableClientStream(GetNextStreamId(), this);
+      new QuicReliableClientStream(GetNextStreamId(), this, net_log_);
   ActivateStream(stream);
+  ++num_total_streams_;

[eroman, 2013/02/05 23:52:40]

Not familiar with this code, but should num_total_streams_ ever decrease?

i.e. i noticed there is the function GetNumOpenStreams(), how does that fit in?

[Ryan Hamilton, 2013/02/06 16:40:15]

No, it should not.  It is the total number of streams ever seen on the
connection.
 
open streams does go up and down as new streams are created and then closed. 
total streams will always be >= open streams.

   return stream;
 }
 
 QuicCryptoClientStream* QuicClientSession::GetCryptoStream() {
   return &crypto_stream_;
 };
 
 int QuicClientSession::CryptoConnect(const CompletionCallback& callback) {
   if (!crypto_stream_.CryptoConnect()) {
     // TODO(wtc): change crypto_stream_.CryptoConnect() to return a
@@ skipping 51 matching lines @@
 }
 
 void QuicClientSession::CloseSessionOnError(int error) {
   while (!streams()->empty()) {
     ReliableQuicStream* stream = streams()->begin()->second;
     QuicStreamId id = stream->id();
     static_cast<QuicReliableClientStream*>(stream)->OnError(error);
     CloseStream(id);
   }
   stream_factory_->OnSessionClose(this);
+  net_log_.BeginEvent(
+      NetLog::TYPE_QUIC_SESSION,
+      NetLog::IntegerCallback("error", error));

[eroman, 2013/02/05 23:52:40]

"error" --> "net_error", per the documentation

[Ryan Hamilton, 2013/02/06 16:40:15]

Argh!  I changed it in the callback I wrote, but simply cut/paste this code.
Fixed.

 }
 
 Value* QuicClientSession::GetInfoAsValue(const HostPortPair& pair) const {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString("host_port_pair", pair.ToString());
   dict->SetInteger("open_streams", GetNumOpenStreams());
+  dict->SetInteger("total_streams", num_total_streams_);
   dict->SetString("peer_address", peer_address().ToString());
   dict->SetString("guid", base::Uint64ToString(guid()));
   return dict;
 }
 
 void QuicClientSession::OnReadComplete(int result) {
   read_pending_ = false;
   // TODO(rch): Inform the connection about the result.
   if (result > 0) {
     scoped_refptr<IOBufferWithSize> buffer(read_buffer_);
     read_buffer_ = new IOBufferWithSize(kMaxPacketSize);
     QuicEncryptedPacket packet(buffer->data(), result);
     IPEndPoint local_address;
     IPEndPoint peer_address;
     helper_->GetLocalAddress(&local_address);
     helper_->GetPeerAddress(&peer_address);
     // ProcessUdpPacket might result in |this| being deleted, so we
     // use a weak pointer to be safe.
     connection()->ProcessUdpPacket(local_address, peer_address, packet);
     if (!connection()->connected()) {
       stream_factory_->OnSessionClose(this);
       return;
     }
     StartReading();
   }
 }
 
 }  // namespace net