Rename SPDY netlog strings to HTTP2.

s/SPDY/HTTP2/ in all source type and event type netlog strings.
Also remove obsolete TYPE_SPDY_SESSION_SEND_CREDENTIAL.
Also git cl format.

BUG=456986

Review URL: https://codereview.chromium.org/934823005

Cr-Commit-Position: refs/heads/master@{#318068}

12 files changed, 169 insertions, 199 deletions

diff --git a/net/base/net_log_event_type_list.h b/net/base/net_log_event_type_list.h
index 21de471..3b286f9 100644
--- a/net/base/net_log_event_type_list.h
+++ b/net/base/net_log_event_type_list.h
@@ -1049,14 +1049,14 @@ EVENT_TYPE(HTTP_TRANSACTION_SEND_REQUEST_HEADERS)
 //   }
 EVENT_TYPE(HTTP_TRANSACTION_SEND_REQUEST_BODY)
 
-// This event is sent for a HTTP request over a SPDY stream.
+// This event is sent for a HTTP request over an HTTP/2 stream.
 // The following parameters are attached:
 //   {
 //     "headers": <The list of header:value pairs>,
 //   }
-EVENT_TYPE(HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS)
+EVENT_TYPE(HTTP_TRANSACTION_HTTP2_SEND_REQUEST_HEADERS)
 
-// This event is sent for a HTTP request over a SPDY stream.
+// This event is sent for a HTTP request over a QUIC stream.
 // The following parameters are attached:
 //   {
 //     "headers": <The list of header:value pairs>,
@@ -1100,25 +1100,27 @@ EVENT_TYPE(HTTP_TRANSACTION_RESTART_AFTER_ERROR)
 //     "host": <The host-port string>,
 //     "proxy": <The Proxy PAC string>,
 //   }
-EVENT_TYPE(SPDY_SESSION)
+EVENT_TYPE(HTTP2_SESSION)
 
-// The SpdySession has been initilized with a socket.
+// The SpdySession has been initialized with a socket.
 //   {
 //     "source_dependency":  <Source identifier for the underlying socket>,
 //   }
-EVENT_TYPE(SPDY_SESSION_INITIALIZED)
+EVENT_TYPE(HTTP2_SESSION_INITIALIZED)
 
-// This event is sent for a SPDY SYN_STREAM.
+// This event is sent for a SPDY SYN_STREAM.  Note that there is no SYN_STREAM
+// frame in HTTP/2.
 // The following parameters are attached:
 //   {
 //     "flags": <The control frame flags>,
 //     "headers": <The list of header:value pairs>,
 //     "id": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SYN_STREAM)
+EVENT_TYPE(HTTP2_SESSION_SYN_STREAM)
 
 // This event is sent for a SPDY SYN_STREAM pushed by the server, where a
-// net::URLRequest is already waiting for the stream.
+// net::URLRequest is already waiting for the stream.  Note that there is no
+// SYN_STREAM frame in HTTP/2.
 // The following parameters are attached:
 //   {
 //     "flags": <The control frame flags>,
@@ -1126,59 +1128,60 @@ EVENT_TYPE(SPDY_SESSION_SYN_STREAM)
 //     "id": <The stream id>,
 //     "associated_stream": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_PUSHED_SYN_STREAM)
+EVENT_TYPE(HTTP2_SESSION_PUSHED_SYN_STREAM)
 
-// This event is sent for a sending SPDY HEADERS frame.
+// This event is sent for sending an HTTP/2 (or SPDY) HEADERS frame.
 // The following parameters are attached:
 //   {
 //     "flags": <The control frame flags>,
 //     "headers": <The list of header:value pairs>,
 //     "id": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SEND_HEADERS)
+EVENT_TYPE(HTTP2_SESSION_SEND_HEADERS)
 
-// This event is sent for a receiving SPDY HEADERS frame.
+// This event is sent for receiving an HTTP/2 (or SPDY) HEADERS frame.
 // The following parameters are attached:
 //   {
 //     "flags": <The control frame flags>,
 //     "headers": <The list of header:value pairs>,
 //     "id": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECV_HEADERS)
+EVENT_TYPE(HTTP2_SESSION_RECV_HEADERS)
 
-// This event is sent for a SPDY SYN_REPLY.
+// This event is sent for a SPDY SYN_REPLY.  Not that there is no SYN_REPLY
+// frame in HTTP/2.
 // The following parameters are attached:
 //   {
 //     "flags": <The control frame flags>,
 //     "headers": <The list of header:value pairs>,
 //     "id": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SYN_REPLY)
+EVENT_TYPE(HTTP2_SESSION_SYN_REPLY)
 
-// On sending a SPDY SETTINGS frame.
+// On sending an HTTP/2 (or SPDY) SETTINGS frame.
 // The following parameters are attached:
 //   {
 //     "settings": <The list of setting id, flags and value>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SEND_SETTINGS)
+EVENT_TYPE(HTTP2_SESSION_SEND_SETTINGS)
 
-// Receipt of a SPDY SETTINGS frame is received.
+// Receipt of an HTTP/2 (or SPDY) SETTINGS frame is received.
 // The following parameters are attached:
 //   {
 //     "host": <The host-port string>,
 //     "clear_persisted": <Boolean indicating whether to clear all persisted
 //                         settings data for the given host>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECV_SETTINGS)
+EVENT_TYPE(HTTP2_SESSION_RECV_SETTINGS)
 
-// Receipt of a SPDY SETTING frame.
+// Receipt of an individual HTTP/2 (or SPDY) setting.
 // The following parameters are attached:
 //   {
 //     "id":    <The setting id>,
 //     "flags": <The setting flags>,
 //     "value": <The setting value>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECV_SETTING)
+EVENT_TYPE(HTTP2_SESSION_RECV_SETTING)
 
 // The receipt of a RST_STREAM
 // The following parameters are attached:
@@ -1186,7 +1189,7 @@ EVENT_TYPE(SPDY_SESSION_RECV_SETTING)
 //     "stream_id": <The stream ID for the window update>,
 //     "status": <The reason for the RST_STREAM>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RST_STREAM)
+EVENT_TYPE(HTTP2_SESSION_RST_STREAM)
 
 // Sending of a RST_STREAM
 // The following parameters are attached:
@@ -1195,17 +1198,17 @@ EVENT_TYPE(SPDY_SESSION_RST_STREAM)
 //     "status": <The reason for the RST_STREAM>,
 //     "description": <The textual description for the RST_STREAM>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SEND_RST_STREAM)
+EVENT_TYPE(HTTP2_SESSION_SEND_RST_STREAM)
 
-// Sending of a SPDY PING frame.
+// Sending of an HTTP/2 (or SPDY) PING frame.
 // The following parameters are attached:
 //   {
 //     "unique_id": <The unique id of the PING message>,
 //     "type": <The PING type ("sent", "received")>,
 //   }
-EVENT_TYPE(SPDY_SESSION_PING)
+EVENT_TYPE(HTTP2_SESSION_PING)
 
-// Receipt of a SPDY GOAWAY frame.
+// Receipt of an HTTP/2 (or SPDY) GOAWAY frame.
 // The following parameters are attached:
 //   {
 //     "last_accepted_stream_id": <Last stream id accepted by the server, duh>,
@@ -1213,43 +1216,37 @@ EVENT_TYPE(SPDY_SESSION_PING)
 //     "unclaimed_streams":       <Number of unclaimed push streams>,
 //     "status":                  <The reason for the GOAWAY>,
 //   }
-EVENT_TYPE(SPDY_SESSION_GOAWAY)
+EVENT_TYPE(HTTP2_SESSION_GOAWAY)
 
-// Receipt of a SPDY WINDOW_UPDATE frame (which controls the send window).
+// Receipt of an HTTP/2 (or SPDY) WINDOW_UPDATE frame (which controls the send
+// window).
 //   {
 //     "stream_id": <The stream ID for the window update>,
 //     "delta"    : <The delta window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECEIVED_WINDOW_UPDATE_FRAME)
+EVENT_TYPE(HTTP2_SESSION_RECEIVED_WINDOW_UPDATE_FRAME)
 
-// Sending of a SPDY WINDOW_UPDATE frame (which controls the receive window).
+// Sending of an HTTP/2 (or SPDY) WINDOW_UPDATE frame (which controls the
+// receive window).
 //   {
 //     "stream_id": <The stream ID for the window update>,
 //     "delta"    : <The delta window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SENT_WINDOW_UPDATE_FRAME)
+EVENT_TYPE(HTTP2_SESSION_SENT_WINDOW_UPDATE_FRAME)
 
 // This event indicates that the send window has been updated for a session.
 //   {
 //     "delta":      <The window size delta>,
 //     "new_window": <The new window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_UPDATE_SEND_WINDOW)
+EVENT_TYPE(HTTP2_SESSION_UPDATE_SEND_WINDOW)
 
 // This event indicates that the recv window has been updated for a session.
 //   {
 //     "delta":      <The window size delta>,
 //     "new_window": <The new window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_UPDATE_RECV_WINDOW)
-
-// Sending of a SPDY CREDENTIAL frame (which sends a certificate or
-// certificate chain to the server).
-//   {
-//     "slot"     : <The slot that this certificate should be stored in>,
-//     "origin"   : <The origin this certificate should be used for>,
-//   }
-EVENT_TYPE(SPDY_SESSION_SEND_CREDENTIAL)
+EVENT_TYPE(HTTP2_SESSION_UPDATE_RECV_WINDOW)
 
 // Sending a data frame
 //   {
@@ -1257,7 +1254,7 @@ EVENT_TYPE(SPDY_SESSION_SEND_CREDENTIAL)
 //     "length"   : <The size of data sent>,
 //     "flags"    : <Send data flags>,
 //   }
-EVENT_TYPE(SPDY_SESSION_SEND_DATA)
+EVENT_TYPE(HTTP2_SESSION_SEND_DATA)
 
 // Receiving a data frame
 //   {
@@ -1265,50 +1262,50 @@ EVENT_TYPE(SPDY_SESSION_SEND_DATA)
 //     "length"   : <The size of data received>,
 //     "flags"    : <Receive data flags>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECV_DATA)
+EVENT_TYPE(HTTP2_SESSION_RECV_DATA)
 
-// This event is sent for a receiving SPDY PUSH_PROMISE frame.
+// This event is sent for receiving an HTTP/2 (or SPDY) PUSH_PROMISE frame.
 // The following parameters are attached:
 //   {
 //     "headers": <The list of header:value pairs>,
 //     "id": <The stream id>,
 //     "promised_stream_id": <The stream id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_RECV_PUSH_PROMISE)
+EVENT_TYPE(HTTP2_SESSION_RECV_PUSH_PROMISE)
 
 // A stream is stalled by the session send window being closed.
-EVENT_TYPE(SPDY_SESSION_STREAM_STALLED_BY_SESSION_SEND_WINDOW)
+EVENT_TYPE(HTTP2_SESSION_STREAM_STALLED_BY_SESSION_SEND_WINDOW)
 
 // A stream is stalled by its send window being closed.
-EVENT_TYPE(SPDY_SESSION_STREAM_STALLED_BY_STREAM_SEND_WINDOW)
+EVENT_TYPE(HTTP2_SESSION_STREAM_STALLED_BY_STREAM_SEND_WINDOW)
 
 // Session is closing
 //   {
 //     "net_error"  : <The error status of the closure>,
 //     "description": <The textual description for the closure>,
 //   }
-EVENT_TYPE(SPDY_SESSION_CLOSE)
+EVENT_TYPE(HTTP2_SESSION_CLOSE)
 
 // Event when the creation of a stream is stalled because we're at
 // the maximum number of concurrent streams.
-EVENT_TYPE(SPDY_SESSION_STALLED_MAX_STREAMS)
+EVENT_TYPE(HTTP2_SESSION_STALLED_MAX_STREAMS)
 
 // Received a value for initial window size in SETTINGS frame with
 // flow control turned off.
-EVENT_TYPE(SPDY_SESSION_INITIAL_WINDOW_SIZE_NO_FLOW_CONTROL)
+EVENT_TYPE(HTTP2_SESSION_INITIAL_WINDOW_SIZE_NO_FLOW_CONTROL)
 
 // Received an out-of-range value for initial window size in SETTINGS
 // frame.
 //   {
 //     "initial_window_size"  : <The initial window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_INITIAL_WINDOW_SIZE_OUT_OF_RANGE)
+EVENT_TYPE(HTTP2_SESSION_INITIAL_WINDOW_SIZE_OUT_OF_RANGE)
 
 // Updating streams send window size by the delta window size.
 //   {
 //     "delta_window_size"    : <The delta window size>,
 //   }
-EVENT_TYPE(SPDY_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE)
+EVENT_TYPE(HTTP2_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE)
 
 // ------------------------------------------------------------------------
 // SpdySessionPool
@@ -1318,49 +1315,50 @@ EVENT_TYPE(SPDY_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE)
 //   {
 //     "source_dependency": <The session id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_POOL_FOUND_EXISTING_SESSION)
+EVENT_TYPE(HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION)
 
 // This event indicates the pool is reusing an existing session from an
 // IP pooling match.
 //   {
 //     "source_dependency": <The session id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL)
+EVENT_TYPE(HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL)
 
 // This event indicates the pool created a new session
 //   {
 //     "source_dependency": <The session id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_POOL_CREATED_NEW_SESSION)
+EVENT_TYPE(HTTP2_SESSION_POOL_CREATED_NEW_SESSION)
 
-// This event indicates that a SSL socket has been upgraded to a SPDY session.
+// This event indicates that a SSL socket has been upgraded to an HTTP/2 (or
+// SPDY) session.
 //   {
 //     "source_dependency": <The session id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET)
+EVENT_TYPE(HTTP2_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET)
 
 // This event indicates that the session has been removed.
 //   {
 //     "source_dependency": <The session id>,
 //   }
-EVENT_TYPE(SPDY_SESSION_POOL_REMOVE_SESSION)
+EVENT_TYPE(HTTP2_SESSION_POOL_REMOVE_SESSION)
 
 // ------------------------------------------------------------------------
 // SpdyStream
 // ------------------------------------------------------------------------
 
-// The begin and end of a SPDY STREAM.
-EVENT_TYPE(SPDY_STREAM)
+// The begin and end of an HTTP/2 (or SPDY) STREAM.
+EVENT_TYPE(HTTP2_STREAM)
 
 // A stream is attached to a pushed stream.
 //   {
 //     "stream_id":  <The stream id>,
 //     "url":        <The url of the pushed resource>,
 //   }
-EVENT_TYPE(SPDY_STREAM_ADOPTED_PUSH_STREAM)
+EVENT_TYPE(HTTP2_STREAM_ADOPTED_PUSH_STREAM)
 
 // A stream is unstalled by flow control.
-EVENT_TYPE(SPDY_STREAM_FLOW_CONTROL_UNSTALLED)
+EVENT_TYPE(HTTP2_STREAM_FLOW_CONTROL_UNSTALLED)
 
 // This event indicates that the send window has been updated for a stream.
 //   {
@@ -1368,7 +1366,7 @@ EVENT_TYPE(SPDY_STREAM_FLOW_CONTROL_UNSTALLED)
 //     "delta":      <The window size delta>,
 //     "new_window": <The new window size>,
 //   }
-EVENT_TYPE(SPDY_STREAM_UPDATE_SEND_WINDOW)
+EVENT_TYPE(HTTP2_STREAM_UPDATE_SEND_WINDOW)
 
 // This event indicates that the recv window has been updated for a stream.
 //   {
@@ -1376,7 +1374,7 @@ EVENT_TYPE(SPDY_STREAM_UPDATE_SEND_WINDOW)
 //     "delta":      <The window size delta>,
 //     "new_window": <The new window size>,
 //   }
-EVENT_TYPE(SPDY_STREAM_UPDATE_RECV_WINDOW)
+EVENT_TYPE(HTTP2_STREAM_UPDATE_RECV_WINDOW)
 
 // This event indicates a stream error
 //   {
@@ -1384,14 +1382,14 @@ EVENT_TYPE(SPDY_STREAM_UPDATE_RECV_WINDOW)
 //     "status":      <The error status>,
 //     "description": <The textual description for the error>,
 //   }
-EVENT_TYPE(SPDY_STREAM_ERROR)
+EVENT_TYPE(HTTP2_STREAM_ERROR)
 
 // ------------------------------------------------------------------------
 // SpdyProxyClientSocket
 // ------------------------------------------------------------------------
 
-EVENT_TYPE(SPDY_PROXY_CLIENT_SESSION)
-// Identifies the SPDY session a source is using.
+EVENT_TYPE(HTTP2_PROXY_CLIENT_SESSION)
+// Identifies the HTTP/2 (or SPDY) session a source is using.
 //   {
 //     "source_dependency":  <Source identifier for the underlying session>,
 //   }
diff --git a/net/base/net_log_logger_unittest.cc b/net/base/net_log_logger_unittest.cc
index 256ae59..16fea58 100644
--- a/net/base/net_log_logger_unittest.cc
+++ b/net/base/net_log_logger_unittest.cc
@@ -78,7 +78,7 @@ TEST_F(NetLogLoggerTest, GeneratesValidJSONWithOneEvent) {
   scoped_ptr<NetLogLogger> logger(new NetLogLogger(file, *constants));
 
   const int kDummyId = 1;
-  NetLog::Source source(NetLog::SOURCE_SPDY_SESSION, kDummyId);
+  NetLog::Source source(NetLog::SOURCE_HTTP2_SESSION, kDummyId);
   NetLog::EntryData entry_data(NetLog::TYPE_PROXY_SERVICE,
                                source,
                                NetLog::PHASE_BEGIN,
@@ -109,7 +109,7 @@ TEST_F(NetLogLoggerTest, GeneratesValidJSONWithMultipleEvents) {
   scoped_ptr<NetLogLogger> logger(new NetLogLogger(file, *constants));
 
   const int kDummyId = 1;
-  NetLog::Source source(NetLog::SOURCE_SPDY_SESSION, kDummyId);
+  NetLog::Source source(NetLog::SOURCE_HTTP2_SESSION, kDummyId);
   NetLog::EntryData entry_data(NetLog::TYPE_PROXY_SERVICE,
                                source,
                                NetLog::PHASE_BEGIN,
diff --git a/net/base/net_log_source_type_list.h b/net/base/net_log_source_type_list.h
index dbad470..e7939aa 100644
--- a/net/base/net_log_source_type_list.h
+++ b/net/base/net_log_source_type_list.h
@@ -12,7 +12,7 @@ SOURCE_TYPE(URL_REQUEST)
 SOURCE_TYPE(PROXY_SCRIPT_DECIDER)
 SOURCE_TYPE(CONNECT_JOB)
 SOURCE_TYPE(SOCKET)
-SOURCE_TYPE(SPDY_SESSION)
+SOURCE_TYPE(HTTP2_SESSION)
 SOURCE_TYPE(QUIC_SESSION)
 SOURCE_TYPE(HOST_RESOLVER_IMPL_JOB)
 SOURCE_TYPE(DISK_CACHE_ENTRY)
diff --git a/net/spdy/spdy_http_stream.cc b/net/spdy/spdy_http_stream.cc
index 25be332..b6521c8 100644
--- a/net/spdy/spdy_http_stream.cc
+++ b/net/spdy/spdy_http_stream.cc
@@ -266,7 +266,7 @@ int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
         stream_->GetProtocolVersion(), direct_,
         headers.get());
     stream_->net_log().AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
+        NetLog::TYPE_HTTP_TRANSACTION_HTTP2_SEND_REQUEST_HEADERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
     result =
         stream_->SendRequestHeaders(
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index e286333..83f6bc0 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -3780,8 +3780,7 @@ TEST_P(SpdyNetworkTransactionTest, NetLog) {
 
   // Check that we logged all the headers correctly
   pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
-      net::NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
+      entries, 0, net::NetLog::TYPE_HTTP2_SESSION_SYN_STREAM,
       net::NetLog::PHASE_NONE);
 
   base::ListValue* header_list;
diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc
index 661cfd9..fbfcc1d 100644
--- a/net/spdy/spdy_proxy_client_socket.cc
+++ b/net/spdy/spdy_proxy_client_socket.cc
@@ -57,7 +57,7 @@ SpdyProxyClientSocket::SpdyProxyClientSocket(
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source_net_log.source().ToEventParametersCallback());
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
+      NetLog::TYPE_HTTP2_PROXY_CLIENT_SESSION,
       spdy_stream->net_log().source().ToEventParametersCallback());
 
   spdy_stream_->SetDelegate(this);
diff --git a/net/spdy/spdy_proxy_client_socket_unittest.cc b/net/spdy/spdy_proxy_client_socket_unittest.cc
index a707ef4..67df240 100644
--- a/net/spdy/spdy_proxy_client_socket_unittest.cc
+++ b/net/spdy/spdy_proxy_client_socket_unittest.cc
@@ -1281,8 +1281,8 @@ TEST_P(SpdyProxyClientSocketTest, NetLog) {
   ASSERT_EQ(entry_list.size(), 10u);
   EXPECT_TRUE(LogContainsBeginEvent(entry_list, 0, NetLog::TYPE_SOCKET_ALIVE));
   EXPECT_TRUE(LogContainsEvent(entry_list, 1,
-                  NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
-                  NetLog::PHASE_NONE));
+                               NetLog::TYPE_HTTP2_PROXY_CLIENT_SESSION,
+                               NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsBeginEvent(entry_list, 2,
                   NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
   EXPECT_TRUE(LogContainsEvent(entry_list, 3,
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index dcdc928..b6318e0 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -661,7 +661,7 @@ SpdySession::SpdySession(
       session_send_window_size_(0),
       session_recv_window_size_(0),
       session_unacked_recv_window_bytes_(0),
-      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SPDY_SESSION)),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP2_SESSION)),
       verify_domain_authentication_(verify_domain_authentication),
       enable_sending_initial_data_(enable_sending_initial_data),
       enable_compression_(enable_compression),
@@ -678,7 +678,7 @@ SpdySession::SpdySession(
   DCHECK_LE(protocol_, kProtoSPDYMaximumVersion);
   DCHECK(HttpStreamFactory::spdy_enabled());
   net_log_.BeginEvent(
-      NetLog::TYPE_SPDY_SESSION,
+      NetLog::TYPE_HTTP2_SESSION,
       base::Bind(&NetLogSpdySessionCallback, &host_port_proxy_pair()));
   next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
@@ -697,7 +697,7 @@ SpdySession::~SpdySession() {
 
   RecordHistograms();
 
-  net_log_.EndEvent(NetLog::TYPE_SPDY_SESSION);
+  net_log_.EndEvent(NetLog::TYPE_HTTP2_SESSION);
 }
 
 void SpdySession::InitializeWithSocket(
@@ -754,10 +754,10 @@ void SpdySession::InitializeWithSocket(
       protocol_ - kProtoSPDYHistogramOffset,
       kProtoSPDYMaximumVersion - kProtoSPDYMinimumVersion + 1);
 
-  net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_INITIALIZED,
-                    base::Bind(&NetLogSpdyInitializedCallback,
-                               connection_->socket()->NetLog().source(),
-                               protocol_));
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP2_SESSION_INITIALIZED,
+      base::Bind(&NetLogSpdyInitializedCallback,
+                 connection_->socket()->NetLog().source(), protocol_));
 
   DCHECK_EQ(availability_state_, STATE_AVAILABLE);
   connection_->AddHigherLayeredPool(this);
@@ -852,7 +852,7 @@ int SpdySession::TryCreateStream(
   }
 
   stalled_streams_++;
-  net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_STALLED_MAX_STREAMS);
+  net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_STALLED_MAX_STREAMS);
   RequestPriority priority = request->priority();
   CHECK_GE(priority, MINIMUM_PRIORITY);
   CHECK_LE(priority, MAXIMUM_PRIORITY);
@@ -1083,13 +1083,11 @@ scoped_ptr<SpdyFrame> SpdySession::CreateSynStream(
   streams_initiated_count_++;
 
   if (net_log().IsLogging()) {
-    net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
-                       base::Bind(&NetLogSpdySynStreamSentCallback,
-                                  &block,
+    net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_SYN_STREAM,
+                       base::Bind(&NetLogSpdySynStreamSentCallback, &block,
                                   (flags & CONTROL_FLAG_FIN) != 0,
                                   (flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0,
-                                  spdy_priority,
-                                  stream_id));
+                                  spdy_priority, stream_id));
   }
 
   return syn_frame.Pass();
@@ -1160,7 +1158,7 @@ scoped_ptr<SpdyBuffer> SpdySession::CreateDataBuffer(SpdyStreamId stream_id,
       // might end up being stalled by the session also.
       QueueSendStalledStream(*stream);
       net_log().AddEvent(
-          NetLog::TYPE_SPDY_SESSION_STREAM_STALLED_BY_STREAM_SEND_WINDOW,
+          NetLog::TYPE_HTTP2_SESSION_STREAM_STALLED_BY_STREAM_SEND_WINDOW,
           NetLog::IntegerCallback("stream_id", stream_id));
       return scoped_ptr<SpdyBuffer>();
     }
@@ -1175,7 +1173,7 @@ scoped_ptr<SpdyBuffer> SpdySession::CreateDataBuffer(SpdyStreamId stream_id,
       stream->set_send_stalled_by_flow_control(true);
       QueueSendStalledStream(*stream);
       net_log().AddEvent(
-          NetLog::TYPE_SPDY_SESSION_STREAM_STALLED_BY_SESSION_SEND_WINDOW,
+          NetLog::TYPE_HTTP2_SESSION_STREAM_STALLED_BY_SESSION_SEND_WINDOW,
           NetLog::IntegerCallback("stream_id", stream_id));
       return scoped_ptr<SpdyBuffer>();
     }
@@ -1191,10 +1189,9 @@ scoped_ptr<SpdyBuffer> SpdySession::CreateDataBuffer(SpdyStreamId stream_id,
     flags = static_cast<SpdyDataFlags>(flags & ~DATA_FLAG_FIN);
 
   if (net_log().IsLogging()) {
-    net_log().AddEvent(
-        NetLog::TYPE_SPDY_SESSION_SEND_DATA,
-        base::Bind(&NetLogSpdyDataCallback, stream_id, effective_len,
-                   (flags & DATA_FLAG_FIN) != 0));
+    net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_SEND_DATA,
+                       base::Bind(&NetLogSpdyDataCallback, stream_id,
+                                  effective_len, (flags & DATA_FLAG_FIN) != 0));
   }
 
   // Send PrefacePing for DATA_FRAMEs with nonzero payload size.
@@ -1333,7 +1330,7 @@ void SpdySession::EnqueueResetStreamFrame(SpdyStreamId stream_id,
   DCHECK_NE(stream_id, 0u);
 
   net_log().AddEvent(
-      NetLog::TYPE_SPDY_SESSION_SEND_RST_STREAM,
+      NetLog::TYPE_HTTP2_SESSION_SEND_RST_STREAM,
       base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));
 
   DCHECK(buffered_spdy_framer_.get());
@@ -1743,7 +1740,7 @@ void SpdySession::DoDrainSession(Error err, const std::string& description) {
   error_on_close_ = err;
 
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_CLOSE,
+      NetLog::TYPE_HTTP2_SESSION_CLOSE,
       base::Bind(&NetLogSpdySessionCloseCallback, err, &description));
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.SpdySession.ClosedOnError", -err);
@@ -1980,7 +1977,7 @@ base::WeakPtr<SpdyStream> SpdySession::GetActivePushStream(const GURL& url) {
     return base::WeakPtr<SpdyStream>();
   }
 
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ADOPTED_PUSH_STREAM,
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_ADOPTED_PUSH_STREAM,
                     base::Bind(&NetLogSpdyAdoptedPushStreamCallback,
                                active_it->second.stream->stream_id(), &url));
   return active_it->second.stream->GetWeakPtr();
@@ -2064,7 +2061,7 @@ void SpdySession::OnStreamFrameData(SpdyStreamId stream_id,
   DCHECK_LT(len, 1u << 24);
   if (net_log().IsLogging()) {
     net_log().AddEvent(
-        NetLog::TYPE_SPDY_SESSION_RECV_DATA,
+        NetLog::TYPE_HTTP2_SESSION_RECV_DATA,
         base::Bind(&NetLogSpdyDataCallback, stream_id, len, fin));
   }
 
@@ -2117,10 +2114,9 @@ void SpdySession::OnSettings(bool clear_persisted) {
     http_server_properties_->ClearSpdySettings(host_port_pair());
 
   if (net_log_.IsLogging()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_SPDY_SESSION_RECV_SETTINGS,
-        base::Bind(&NetLogSpdySettingsCallback, host_port_pair(),
-                   clear_persisted));
+    net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_SETTINGS,
+                      base::Bind(&NetLogSpdySettingsCallback, host_port_pair(),
+                                 clear_persisted));
   }
 
   if (GetProtocolVersion() >= SPDY4) {
@@ -2150,12 +2146,9 @@ void SpdySession::OnSetting(SpdySettingsIds id,
 
   // Log the setting.
   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));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_SETTING,
+                    base::Bind(&NetLogSpdySettingCallback, id, protocol_version,
+                               static_cast<SpdySettingsFlags>(flags), value));
 }
 
 void SpdySession::OnSendCompressedFrame(
@@ -2235,10 +2228,9 @@ void SpdySession::OnSynStream(SpdyStreamId stream_id,
 
   if (net_log_.IsLogging()) {
     net_log_.AddEvent(
-        NetLog::TYPE_SPDY_SESSION_PUSHED_SYN_STREAM,
-        base::Bind(&NetLogSpdySynStreamReceivedCallback,
-                   &headers, fin, unidirectional, priority,
-                   stream_id, associated_stream_id));
+        NetLog::TYPE_HTTP2_SESSION_PUSHED_SYN_STREAM,
+        base::Bind(&NetLogSpdySynStreamReceivedCallback, &headers, fin,
+                   unidirectional, priority, stream_id, associated_stream_id));
   }
 
   // Split headers to simulate push promise and response.
@@ -2307,10 +2299,9 @@ void SpdySession::OnSynReply(SpdyStreamId stream_id,
   base::TimeTicks recv_first_byte_time = time_func_();
 
   if (net_log().IsLogging()) {
-    net_log().AddEvent(
-        NetLog::TYPE_SPDY_SESSION_SYN_REPLY,
-        base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,
-                   &headers, fin, stream_id));
+    net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_SYN_REPLY,
+                       base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,
+                                  &headers, fin, stream_id));
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
@@ -2353,10 +2344,9 @@ void SpdySession::OnHeaders(SpdyStreamId stream_id,
   CHECK(in_io_loop_);
 
   if (net_log().IsLogging()) {
-    net_log().AddEvent(
-        NetLog::TYPE_SPDY_SESSION_RECV_HEADERS,
-        base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,
-                   &headers, fin, stream_id));
+    net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_HEADERS,
+                       base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,
+                                  &headers, fin, stream_id));
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
@@ -2417,9 +2407,8 @@ void SpdySession::OnRstStream(SpdyStreamId stream_id,
 
   std::string description;
   net_log().AddEvent(
-      NetLog::TYPE_SPDY_SESSION_RST_STREAM,
-      base::Bind(&NetLogSpdyRstCallback,
-                 stream_id, status, &description));
+      NetLog::TYPE_HTTP2_SESSION_RST_STREAM,
+      base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
@@ -2459,12 +2448,10 @@ void SpdySession::OnGoAway(SpdyStreamId last_accepted_stream_id,
 
   // TODO(jgraettinger): UMA histogram on |status|.
 
-  net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_GOAWAY,
-      base::Bind(&NetLogSpdyGoAwayCallback,
-                 last_accepted_stream_id,
-                 active_streams_.size(),
-                 unclaimed_pushed_streams_.size(),
-                 status));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_GOAWAY,
+                    base::Bind(&NetLogSpdyGoAwayCallback,
+                               last_accepted_stream_id, active_streams_.size(),
+                               unclaimed_pushed_streams_.size(), status));
   MakeUnavailable();
   if (status == GOAWAY_HTTP_1_1_REQUIRED) {
     // TODO(bnc): Record histogram with number of open streams capped at 50.
@@ -2483,7 +2470,7 @@ void SpdySession::OnPing(SpdyPingId unique_id, bool is_ack) {
   CHECK(in_io_loop_);
 
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_PING,
+      NetLog::TYPE_HTTP2_SESSION_PING,
       base::Bind(&NetLogSpdyPingCallback, unique_id, is_ack, "received"));
 
   // Send response to a PING from server.
@@ -2514,10 +2501,9 @@ void SpdySession::OnWindowUpdate(SpdyStreamId stream_id,
   CHECK(in_io_loop_);
 
   DCHECK_LE(delta_window_size, static_cast<uint32>(kint32max));
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_RECEIVED_WINDOW_UPDATE_FRAME,
-      base::Bind(&NetLogSpdyWindowUpdateFrameCallback,
-                 stream_id, delta_window_size));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECEIVED_WINDOW_UPDATE_FRAME,
+                    base::Bind(&NetLogSpdyWindowUpdateFrameCallback, stream_id,
+                               delta_window_size));
 
   if (stream_id == kSessionFlowControlStreamId) {
     // WINDOW_UPDATE for the session.
@@ -2744,11 +2730,9 @@ void SpdySession::OnPushPromise(SpdyStreamId stream_id,
   CHECK(in_io_loop_);
 
   if (net_log_.IsLogging()) {
-    net_log_.AddEvent(NetLog::TYPE_SPDY_SESSION_RECV_PUSH_PROMISE,
+    net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_PUSH_PROMISE,
                       base::Bind(&NetLogSpdyPushPromiseReceivedCallback,
-                                 &headers,
-                                 stream_id,
-                                 promised_stream_id));
+                                 &headers, stream_id, promised_stream_id));
   }
 
   // Any priority will do.
@@ -2839,7 +2823,7 @@ void SpdySession::SendInitialData() {
 void SpdySession::SendSettings(const SettingsMap& settings) {
   const SpdyMajorVersion protocol_version = GetProtocolVersion();
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
+      NetLog::TYPE_HTTP2_SESSION_SEND_SETTINGS,
       base::Bind(&NetLogSpdySendSettingsCallback, &settings, protocol_version));
   // Create the SETTINGS frame and send it.
   DCHECK(buffered_spdy_framer_.get());
@@ -2859,13 +2843,13 @@ void SpdySession::HandleSetting(uint32 id, uint32 value) {
     case SETTINGS_INITIAL_WINDOW_SIZE: {
       if (flow_control_state_ < FLOW_CONTROL_STREAM) {
         net_log().AddEvent(
-            NetLog::TYPE_SPDY_SESSION_INITIAL_WINDOW_SIZE_NO_FLOW_CONTROL);
+            NetLog::TYPE_HTTP2_SESSION_INITIAL_WINDOW_SIZE_NO_FLOW_CONTROL);
         return;
       }
 
       if (value > static_cast<uint32>(kint32max)) {
         net_log().AddEvent(
-            NetLog::TYPE_SPDY_SESSION_INITIAL_WINDOW_SIZE_OUT_OF_RANGE,
+            NetLog::TYPE_HTTP2_SESSION_INITIAL_WINDOW_SIZE_OUT_OF_RANGE,
             NetLog::IntegerCallback("initial_window_size", value));
         return;
       }
@@ -2876,7 +2860,7 @@ void SpdySession::HandleSetting(uint32 id, uint32 value) {
       stream_initial_send_window_size_ = static_cast<int32>(value);
       UpdateStreamsSendWindowSize(delta_window_size);
       net_log().AddEvent(
-          NetLog::TYPE_SPDY_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE,
+          NetLog::TYPE_HTTP2_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE,
           NetLog::IntegerCallback("delta_window_size", delta_window_size));
       break;
     }
@@ -2922,10 +2906,9 @@ void SpdySession::SendWindowUpdateFrame(SpdyStreamId stream_id,
     CHECK_EQ(stream_id, kSessionFlowControlStreamId);
   }
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_SENT_WINDOW_UPDATE_FRAME,
-      base::Bind(&NetLogSpdyWindowUpdateFrameCallback,
-                 stream_id, delta_window_size));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_SENT_WINDOW_UPDATE_FRAME,
+                    base::Bind(&NetLogSpdyWindowUpdateFrameCallback, stream_id,
+                               delta_window_size));
 
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<SpdyFrame> window_update_frame(
@@ -2941,7 +2924,7 @@ void SpdySession::WritePingFrame(SpdyPingId unique_id, bool is_ack) {
 
   if (net_log().IsLogging()) {
     net_log().AddEvent(
-        NetLog::TYPE_SPDY_SESSION_PING,
+        NetLog::TYPE_HTTP2_SESSION_PING,
         base::Bind(&NetLogSpdyPingCallback, unique_id, is_ack, "sent"));
   }
   if (!is_ack) {
@@ -3150,10 +3133,9 @@ void SpdySession::IncreaseSendWindowSize(int32 delta_window_size) {
 
   session_send_window_size_ += delta_window_size;
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdySessionWindowUpdateCallback,
-                 delta_window_size, session_send_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_SEND_WINDOW,
+                    base::Bind(&NetLogSpdySessionWindowUpdateCallback,
+                               delta_window_size, session_send_window_size_));
 
   DCHECK(!IsSendStalled());
   ResumeSendStalledStreams();
@@ -3173,10 +3155,9 @@ void SpdySession::DecreaseSendWindowSize(int32 delta_window_size) {
 
   session_send_window_size_ -= delta_window_size;
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdySessionWindowUpdateCallback,
-                 -delta_window_size, session_send_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_SEND_WINDOW,
+                    base::Bind(&NetLogSpdySessionWindowUpdateCallback,
+                               -delta_window_size, session_send_window_size_));
 }
 
 void SpdySession::OnReadBufferConsumed(
@@ -3201,10 +3182,9 @@ void SpdySession::IncreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK_LE(delta_window_size, kint32max - session_recv_window_size_);
 
   session_recv_window_size_ += delta_window_size;
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdySessionWindowUpdateCallback,
-                 delta_window_size, session_recv_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,
+                    base::Bind(&NetLogSpdySessionWindowUpdateCallback,
+                               delta_window_size, session_recv_window_size_));
 
   session_unacked_recv_window_bytes_ += delta_window_size;
   if (session_unacked_recv_window_bytes_ >
@@ -3235,10 +3215,9 @@ void SpdySession::DecreaseRecvWindowSize(int32 delta_window_size) {
   }
 
   session_recv_window_size_ -= delta_window_size;
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdySessionWindowUpdateCallback,
-                 -delta_window_size, session_recv_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_RECV_WINDOW,
+                    base::Bind(&NetLogSpdySessionWindowUpdateCallback,
+                               -delta_window_size, session_recv_window_size_));
 }
 
 void SpdySession::QueueSendStalledStream(const SpdyStream& stream) {
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
index a2d2ed6..e0f4799 100644
--- a/net/spdy/spdy_session_pool.cc
+++ b/net/spdy/spdy_session_pool.cc
@@ -126,7 +126,7 @@ base::WeakPtr<SpdySession> SpdySessionPool::CreateAvailableSessionFromSocket(
   MapKeyToAvailableSession(key, available_session);
 
   net_log.AddEvent(
-      NetLog::TYPE_SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
+      NetLog::TYPE_HTTP2_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
       available_session->net_log().source().ToEventParametersCallback());
 
   // Look up the IP address for this session so that we can match
@@ -151,7 +151,7 @@ base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
     UMA_HISTOGRAM_ENUMERATION(
         "Net.SpdySessionGet", FOUND_EXISTING, SPDY_SESSION_GET_MAX);
     net_log.AddEvent(
-        NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION,
+        NetLog::TYPE_HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION,
         it->second->net_log().source().ToEventParametersCallback());
     return it->second;
   }
@@ -204,7 +204,7 @@ base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
                               FOUND_EXISTING_FROM_IP_POOL,
                               SPDY_SESSION_GET_MAX);
     net_log.AddEvent(
-        NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
+        NetLog::TYPE_HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
         available_session->net_log().source().ToEventParametersCallback());
     // Add this session to the map so that we can find it next time.
     MapKeyToAvailableSession(key, available_session);
@@ -233,7 +233,7 @@ void SpdySessionPool::RemoveUnavailableSession(
   DCHECK(!IsSessionAvailable(unavailable_session));
 
   unavailable_session->net_log().AddEvent(
-      NetLog::TYPE_SPDY_SESSION_POOL_REMOVE_SESSION,
+      NetLog::TYPE_HTTP2_SESSION_POOL_REMOVE_SESSION,
       unavailable_session->net_log().source().ToEventParametersCallback());
 
   SessionSet::iterator it = sessions_.find(unavailable_session.get());
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index ba3cb61..f8dbdea 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -1651,10 +1651,9 @@ TEST_P(SpdySessionTest, Initialize) {
   log.GetEntries(&entries);
   EXPECT_LT(0u, entries.size());
 
-  // Check that we logged TYPE_SPDY_SESSION_INITIALIZED correctly.
+  // Check that we logged TYPE_HTTP2_SESSION_INITIALIZED correctly.
   int pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
-      net::NetLog::TYPE_SPDY_SESSION_INITIALIZED,
+      entries, 0, net::NetLog::TYPE_HTTP2_SESSION_INITIALIZED,
       net::NetLog::PHASE_NONE);
   EXPECT_LT(0, pos);
 
@@ -1700,8 +1699,7 @@ TEST_P(SpdySessionTest, NetLogOnSessionGoaway) {
 
   // Check that we logged SPDY_SESSION_CLOSE correctly.
   int pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
-      net::NetLog::TYPE_SPDY_SESSION_CLOSE,
+      entries, 0, net::NetLog::TYPE_HTTP2_SESSION_CLOSE,
       net::NetLog::PHASE_NONE);
 
   if (pos < static_cast<int>(entries.size())) {
@@ -1745,11 +1743,9 @@ TEST_P(SpdySessionTest, NetLogOnSessionEOF) {
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged SPDY_SESSION_CLOSE correctly.
-  int pos =
-      net::ExpectLogContainsSomewhere(entries,
-                                      0,
-                                      net::NetLog::TYPE_SPDY_SESSION_CLOSE,
-                                      net::NetLog::PHASE_NONE);
+  int pos = net::ExpectLogContainsSomewhere(
+      entries, 0, net::NetLog::TYPE_HTTP2_SESSION_CLOSE,
+      net::NetLog::PHASE_NONE);
 
   if (pos < static_cast<int>(entries.size())) {
     CapturingNetLog::CapturedEntry entry = entries[pos];
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index e7dcd5b..fc2866b 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -272,9 +272,9 @@ void SpdyStream::IncreaseSendWindowSize(int32 delta_window_size) {
   send_window_size_ += delta_window_size;
 
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, delta_window_size, send_window_size_));
+      NetLog::TYPE_HTTP2_STREAM_UPDATE_SEND_WINDOW,
+      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
+                 delta_window_size, send_window_size_));
 
   PossiblyResumeIfSendStalled();
 }
@@ -297,9 +297,9 @@ void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) {
   send_window_size_ -= delta_window_size;
 
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, -delta_window_size, send_window_size_));
+      NetLog::TYPE_HTTP2_STREAM_UPDATE_SEND_WINDOW,
+      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
+                 -delta_window_size, send_window_size_));
 }
 
 void SpdyStream::OnReadBufferConsumed(
@@ -327,9 +327,9 @@ void SpdyStream::IncreaseRecvWindowSize(int32 delta_window_size) {
 
   recv_window_size_ += delta_window_size;
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, delta_window_size, recv_window_size_));
+      NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,
+      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
+                 delta_window_size, recv_window_size_));
 
   unacked_recv_window_bytes_ += delta_window_size;
   if (unacked_recv_window_bytes_ >
@@ -359,9 +359,9 @@ void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) {
 
   recv_window_size_ -= delta_window_size;
   net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, -delta_window_size, recv_window_size_));
+      NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,
+      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
+                 -delta_window_size, recv_window_size_));
 }
 
 int SpdyStream::GetPeerAddress(IPEndPoint* address) const {
@@ -610,9 +610,9 @@ SpdyMajorVersion SpdyStream::GetProtocolVersion() const {
 }
 
 void SpdyStream::LogStreamError(int status, const std::string& description) {
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ERROR,
-                    base::Bind(&NetLogSpdyStreamErrorCallback,
-                               stream_id_, status, &description));
+  net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_ERROR,
+                    base::Bind(&NetLogSpdyStreamErrorCallback, stream_id_,
+                               status, &description));
 }
 
 void SpdyStream::OnClose(int status) {
@@ -704,9 +704,8 @@ void SpdyStream::PossiblyResumeIfSendStalled() {
   }
   if (send_stalled_by_flow_control_ && !session_->IsSendStalled() &&
       send_window_size_ > 0) {
-    net_log_.AddEvent(
-        NetLog::TYPE_SPDY_STREAM_FLOW_CONTROL_UNSTALLED,
-        NetLog::IntegerCallback("stream_id", stream_id_));
+    net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_FLOW_CONTROL_UNSTALLED,
+                      NetLog::IntegerCallback("stream_id", stream_id_));
     send_stalled_by_flow_control_ = false;
     QueueNextDataFrame();
   }
diff --git a/net/spdy/spdy_stream_unittest.cc b/net/spdy/spdy_stream_unittest.cc
index b8638d9..d5645d8 100644
--- a/net/spdy/spdy_stream_unittest.cc
+++ b/net/spdy/spdy_stream_unittest.cc
@@ -294,8 +294,7 @@ TEST_P(SpdyStreamTest, StreamError) {
 
   // Check that we logged SPDY_STREAM_ERROR correctly.
   int pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
-      net::NetLog::TYPE_SPDY_STREAM_ERROR,
+      entries, 0, net::NetLog::TYPE_HTTP2_STREAM_ERROR,
       net::NetLog::PHASE_NONE);
 
   int stream_id2;