Rename SPDY netlog strings to HTTP2.

net/spdy/spdy_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_stream.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 255 matching lines @@
           "send_window_size_ [current: %d]", delta_window_size, stream_id_,
           send_window_size_);
       session_->ResetStream(stream_id_, RST_STREAM_FLOW_CONTROL_ERROR, desc);
       return;
     }
   }
 
   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();
 }
 
 void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   if (IsClosed())
     return;
 
   // We only call this method when sending a frame. Therefore,
   // |delta_window_size| should be within the valid frame size range.
   DCHECK_GE(delta_window_size, 1);
   DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize);
 
   // |send_window_size_| should have been at least |delta_window_size| for
   // this call to happen.
   DCHECK_GE(send_window_size_, 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(
     size_t consume_size,
     SpdyBuffer::ConsumeSource consume_source) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(consume_size, 1u);
   DCHECK_LE(consume_size, static_cast<size_t>(kint32max));
   IncreaseRecvWindowSize(static_cast<int32>(consume_size));
 }
 
 void SpdyStream::IncreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   // By the time a read is processed by the delegate, this stream may
   // already be inactive.
   if (!session_->IsStreamActive(stream_id_))
     return;
 
   DCHECK_GE(unacked_recv_window_bytes_, 0);
   DCHECK_GE(recv_window_size_, unacked_recv_window_bytes_);
   DCHECK_GE(delta_window_size, 1);
   // Check for overflow.
   DCHECK_LE(delta_window_size, kint32max - recv_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_ >
       session_->stream_initial_recv_window_size() / 2) {
     session_->SendStreamWindowUpdate(
         stream_id_, static_cast<uint32>(unacked_recv_window_bytes_));
     unacked_recv_window_bytes_ = 0;
   }
 }
 
 void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK(session_->IsStreamActive(stream_id_));
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(delta_window_size, 1);
 
   // Since we never decrease the initial receive window size,
   // |delta_window_size| should never cause |recv_window_size_| to go
   // negative. If we do, the receive window isn't being respected.
   if (delta_window_size > recv_window_size_) {
     session_->ResetStream(
         stream_id_, RST_STREAM_PROTOCOL_ERROR,
         "delta_window_size is " + base::IntToString(delta_window_size) +
             " in DecreaseRecvWindowSize, which is larger than the receive " +
             "window size of " + base::IntToString(recv_window_size_));
     return;
   }
 
   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 {
   return session_->GetPeerAddress(address);
 }
 
 int SpdyStream::GetLocalAddress(IPEndPoint* address) const {
   return session_->GetLocalAddress(address);
 }
 
@@ skipping 232 matching lines @@
     pending_send_data_ = NULL;
     return OK;
   }
 }
 
 SpdyMajorVersion SpdyStream::GetProtocolVersion() const {
   return session_->GetProtocolVersion();
 }
 
 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) {
   // In most cases, the stream should already be CLOSED. The exception is when a
   // SpdySession is shutting down while the stream is in an intermediate state.
   io_state_ = STATE_CLOSED;
   response_status_ = status;
   Delegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate)
@@ skipping 71 matching lines @@
 bool SpdyStream::GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) {
   return session_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 void SpdyStream::PossiblyResumeIfSendStalled() {
   if (IsLocallyClosed()) {
     return;
   }
   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();
   }
 }
 
 bool SpdyStream::IsClosed() const {
   return io_state_ == STATE_CLOSED;
 }
 
 bool SpdyStream::IsLocallyClosed() const {
@@ skipping 193 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net