Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

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"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace {
 
-base::Value* NetLogSpdyStreamErrorCallback(
+scoped_ptr<base::Value> NetLogSpdyStreamErrorCallback(
     SpdyStreamId stream_id,
     int status,
     const std::string* description,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetInteger("status", status);
   dict->SetString("description", *description);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogSpdyStreamWindowUpdateCallback(
+scoped_ptr<base::Value> NetLogSpdyStreamWindowUpdateCallback(
     SpdyStreamId stream_id,
     int32 delta,
     int32 window_size,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", stream_id);
   dict->SetInteger("delta", delta);
   dict->SetInteger("window_size", window_size);
-  return dict;
+  return dict.Pass();
 }
 
 bool ContainsUppercaseAscii(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {
     if (*i >= 'A' && *i <= 'Z') {
       return true;
     }
   }
   return false;
 }
@@ skipping 212 matching lines @@
           "Received WINDOW_UPDATE [delta: %d] for stream %d overflows "
           "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_HTTP2_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
-                 delta_window_size, send_window_size_));
+  net_log_.AddEvent(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_HTTP2_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
-                 -delta_window_size, send_window_size_));
+  net_log_.AddEvent(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_HTTP2_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
-                 delta_window_size, recv_window_size_));
+  net_log_.AddEvent(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_ > max_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);
 
   // The receiving window size as the peer knows it is
   // |recv_window_size_ - unacked_recv_window_bytes_|, if more data are sent by
   // the peer, that means that the receive window is not being respected.
   if (delta_window_size > recv_window_size_ - unacked_recv_window_bytes_) {
     session_->ResetStream(
         stream_id_, RST_STREAM_FLOW_CONTROL_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_HTTP2_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
-                 -delta_window_size, recv_window_size_));
+  net_log_.AddEvent(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 243 matching lines @@
     return OK;
   }
 }
 
 SpdyMajorVersion SpdyStream::GetProtocolVersion() const {
   return session_->GetProtocolVersion();
 }
 
 void SpdyStream::LogStreamError(int status, const std::string& description) {
   net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_ERROR,
-                    base::Bind(&NetLogSpdyStreamErrorCallback, stream_id_,
+                    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;
@@ skipping 283 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net