Log SPDY protocol specific setting IDs (alternate).

net/spdy/spdy_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/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 17 matching lines @@
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/http/http_log_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_util.h"
 #include "net/http/transport_security_state.h"
+#include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 
@@ skipping 79 matching lines @@
 }
 
 base::Value* NetLogSpdySessionCallback(const HostPortProxyPair* host_pair,
                                        NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("host", host_pair->first.ToString());
   dict->SetString("proxy", host_pair->second.ToPacString());
   return dict;
 }
 
+base::Value* NetLogSpdyInitializedCallback(NetLog::Source source,
+                                           const NextProto protocol_version,
+                                           NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* dict = new base::DictionaryValue();
+  if (source.IsValid()) {
+    source.AddToEventParameters(dict);
+  }
+  dict->SetString("protocol",
+                  SSLClientSocket::NextProtoToString(protocol_version));
+  return dict;
+}
+
 base::Value* NetLogSpdySettingsCallback(const HostPortPair& host_port_pair,
                                         bool clear_persisted,
                                         NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("host", host_port_pair.ToString());
   dict->SetBoolean("clear_persisted", clear_persisted);
   return dict;
 }
 
 base::Value* NetLogSpdySettingCallback(SpdySettingsIds id,
+                                       const SpdyMajorVersion protocol_version,
                                        SpdySettingsFlags flags,
                                        uint32 value,
                                        NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
-  dict->SetInteger("id", id);
+  dict->SetInteger("id",
+                   SpdyConstants::SerializeSettingId(protocol_version, id));
   dict->SetInteger("flags", flags);
   dict->SetInteger("value", value);
   return dict;
 }
 
-base::Value* NetLogSpdySendSettingsCallback(const SettingsMap* settings,
-                                            NetLog::LogLevel /* log_level */) {
+base::Value* NetLogSpdySendSettingsCallback(
+    const SettingsMap* settings,
+    const SpdyMajorVersion protocol_version,
+    NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   base::ListValue* settings_list = new base::ListValue();
   for (SettingsMap::const_iterator it = settings->begin();
        it != settings->end(); ++it) {
     const SpdySettingsIds id = it->first;
     const SpdySettingsFlags flags = it->second.first;
     const uint32 value = it->second.second;
-    settings_list->Append(new base::StringValue(
-        base::StringPrintf("[id:%u flags:%u value:%u]", id, flags, value)));
+    settings_list->Append(new base::StringValue(base::StringPrintf(
+        "[id:%u flags:%u value:%u]",
+        SpdyConstants::SerializeSettingId(protocol_version, id),
+        flags,
+        value)));
   }
   dict->Set("settings", settings_list);
   return dict;
 }
 
 base::Value* NetLogSpdyWindowUpdateFrameCallback(
     SpdyStreamId stream_id,
     uint32 delta,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
@@ skipping 541 matching lines @@
                              enable_compression_));
   buffered_spdy_framer_->set_visitor(this);
   buffered_spdy_framer_->set_debug_visitor(this);
   UMA_HISTOGRAM_ENUMERATION("Net.SpdyVersion", protocol_, kProtoMaximumVersion);
 #if defined(SPDY_PROXY_AUTH_ORIGIN)
   UMA_HISTOGRAM_BOOLEAN("Net.SpdySessions_DataReductionProxy",
                         host_port_pair().Equals(HostPortPair::FromURL(
                             GURL(SPDY_PROXY_AUTH_ORIGIN))));
 #endif
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_INITIALIZED,
-      connection_->socket()->NetLog().source().ToEventParametersCallback());
+  net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_INITIALIZED,
+                    base::Bind(&NetLogSpdyInitializedCallback,
+                               connection_->socket()->NetLog().source(),
+                               protocol_));
 
   DCHECK_EQ(availability_state_, STATE_AVAILABLE);
   connection_->AddHigherLayeredPool(this);
   if (enable_sending_initial_data_)
     SendInitialData();
   pool_ = pool;
 
   // Bootstrap the read loop.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
@@ skipping 1353 matching lines @@
 
   HandleSetting(id, value);
   http_server_properties_->SetSpdySetting(
       host_port_pair(),
       id,
       static_cast<SpdySettingsFlags>(flags),
       value);
   received_settings_ = true;
 
   // Log the setting.
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_RECV_SETTING,
-      base::Bind(&NetLogSpdySettingCallback,
-                 id, static_cast<SpdySettingsFlags>(flags), value));
+  const SpdyMajorVersion protocol_version = GetProtocolVersion();
+  net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_RECV_SETTING,
+                    base::Bind(&NetLogSpdySettingCallback,
+                               id,
+                               protocol_version,
+                               static_cast<SpdySettingsFlags>(flags),
+                               value));
 }
 
 void SpdySession::OnSendCompressedFrame(
     SpdyStreamId stream_id,
     SpdyFrameType type,
     size_t payload_len,
     size_t frame_len) {
   if (type != SYN_STREAM && type != HEADERS)
     return;
 
@@ skipping 658 matching lines @@
       const uint32 new_val = it->second.second;
       HandleSetting(new_id, new_val);
     }
 
     SendSettings(server_settings_map);
   }
 }
 
 
 void SpdySession::SendSettings(const SettingsMap& settings) {
+  const SpdyMajorVersion protocol_version = GetProtocolVersion();
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
-      base::Bind(&NetLogSpdySendSettingsCallback, &settings));
-
+      base::Bind(&NetLogSpdySendSettingsCallback, &settings, protocol_version));
   // Create the SETTINGS frame and send it.
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<SpdyFrame> settings_frame(
       buffered_spdy_framer_->CreateSettings(settings));
   sent_settings_ = true;
   EnqueueSessionWrite(HIGHEST, SETTINGS, settings_frame.Pass());
 }
 
 void SpdySession::HandleSetting(uint32 id, uint32 value) {
   switch (id) {
@@ skipping 430 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net