net/spdy/spdy_session.cc - Issue 1135373002: Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

Unified Diff: net/spdy/spdy_session.cc

Issue 1135373002: Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value… Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/spdy/spdy_session.cc

diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc

index 3964772f25903585d8477d9abfe530f604efed9e..40c86c0d9bf3e25270e677f39f624ace2ce58fdf 100644

--- a/net/spdy/spdy_session.cc

+++ b/net/spdy/spdy_session.cc

@@ -70,22 +70,23 @@ scoped_ptr<base::ListValue> SpdyHeaderBlockToListValue(

return headers_list.Pass();

}

-base::Value* NetLogSpdySynStreamSentCallback(const SpdyHeaderBlock* headers,

- bool fin,

- bool unidirectional,

- SpdyPriority spdy_priority,

- SpdyStreamId stream_id,

- NetLogCaptureMode capture_mode) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdySynStreamSentCallback(

+ const SpdyHeaderBlock* headers,

+ bool fin,

+ bool unidirectional,

+ SpdyPriority spdy_priority,

+ SpdyStreamId stream_id,

+ NetLogCaptureMode capture_mode) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->Set("headers", SpdyHeaderBlockToListValue(*headers, capture_mode));

dict->SetBoolean("fin", fin);

dict->SetBoolean("unidirectional", unidirectional);

dict->SetInteger("priority", static_cast<int>(spdy_priority));

dict->SetInteger("stream_id", stream_id);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySynStreamReceivedCallback(

+scoped_ptr<base::Value> NetLogSpdySynStreamReceivedCallback(

const SpdyHeaderBlock* headers,

bool fin,

bool unidirectional,

@@ -93,82 +94,85 @@ base::Value* NetLogSpdySynStreamReceivedCallback(

SpdyStreamId stream_id,

SpdyStreamId associated_stream,

NetLogCaptureMode capture_mode) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->Set("headers", SpdyHeaderBlockToListValue(*headers, capture_mode));

dict->SetBoolean("fin", fin);

dict->SetBoolean("unidirectional", unidirectional);

dict->SetInteger("priority", static_cast<int>(spdy_priority));

dict->SetInteger("stream_id", stream_id);

dict->SetInteger("associated_stream", associated_stream);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySynReplyOrHeadersReceivedCallback(

+scoped_ptr<base::Value> NetLogSpdySynReplyOrHeadersReceivedCallback(

const SpdyHeaderBlock* headers,

bool fin,

SpdyStreamId stream_id,

NetLogCaptureMode capture_mode) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->Set("headers", SpdyHeaderBlockToListValue(*headers, capture_mode));

dict->SetBoolean("fin", fin);

dict->SetInteger("stream_id", stream_id);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySessionCloseCallback(

+scoped_ptr<base::Value> NetLogSpdySessionCloseCallback(

int net_error,

const std::string* description,

NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("net_error", net_error);

dict->SetString("description", *description);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySessionCallback(const HostPortProxyPair* host_pair,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdySessionCallback(

+ const HostPortProxyPair* host_pair,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetString("host", host_pair->first.ToString());

dict->SetString("proxy", host_pair->second.ToPacString());

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyInitializedCallback(

+scoped_ptr<base::Value> NetLogSpdyInitializedCallback(

NetLog::Source source,

const NextProto protocol_version,

NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

if (source.IsValid()) {

- source.AddToEventParameters(dict);

+ source.AddToEventParameters(dict.get());

}

dict->SetString("protocol",

SSLClientSocket::NextProtoToString(protocol_version));

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySettingsCallback(const HostPortPair& host_port_pair,

- bool clear_persisted,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdySettingsCallback(

+ const HostPortPair& host_port_pair,

+ bool clear_persisted,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetString("host", host_port_pair.ToString());

dict->SetBoolean("clear_persisted", clear_persisted);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySettingCallback(SpdySettingsIds id,

- const SpdyMajorVersion protocol_version,

- SpdySettingsFlags flags,

- uint32 value,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdySettingCallback(

+ SpdySettingsIds id,

+ const SpdyMajorVersion protocol_version,

+ SpdySettingsFlags flags,

+ uint32 value,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("id",

SpdyConstants::SerializeSettingId(protocol_version, id));

dict->SetInteger("flags", flags);

dict->SetInteger("value", value);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySendSettingsCallback(

+scoped_ptr<base::Value> NetLogSpdySendSettingsCallback(

const SettingsMap* settings,

const SpdyMajorVersion protocol_version,

NetLogCaptureMode /* capture_mode */) {

@@ -186,96 +190,100 @@ base::Value* NetLogSpdySendSettingsCallback(

value)));

}

dict->Set("settings", settings_list.Pass());

- return dict.release();

+ return dict.Pass();

}

-base::Value* NetLogSpdyWindowUpdateFrameCallback(

+scoped_ptr<base::Value> NetLogSpdyWindowUpdateFrameCallback(

SpdyStreamId stream_id,

uint32 delta,

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("delta", delta);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdySessionWindowUpdateCallback(

+scoped_ptr<base::Value> NetLogSpdySessionWindowUpdateCallback(

int32 delta,

int32 window_size,

NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("delta", delta);

dict->SetInteger("window_size", window_size);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyDataCallback(SpdyStreamId stream_id,

- int size,

- bool fin,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdyDataCallback(

+ SpdyStreamId stream_id,

+ int size,

+ bool fin,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("stream_id", static_cast<int>(stream_id));

dict->SetInteger("size", size);

dict->SetBoolean("fin", fin);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyRstCallback(SpdyStreamId stream_id,

- int status,

- const std::string* description,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdyRstCallback(

+ SpdyStreamId stream_id,

+ int status,

+ const std::string* description,

+ NetLogCaptureMode /* capture_mode */) {

+ 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* NetLogSpdyPingCallback(SpdyPingId unique_id,

- bool is_ack,

- const char* type,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdyPingCallback(

+ SpdyPingId unique_id,

+ bool is_ack,

+ const char* type,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("unique_id", static_cast<int>(unique_id));

dict->SetString("type", type);

dict->SetBoolean("is_ack", is_ack);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyGoAwayCallback(SpdyStreamId last_stream_id,

- int active_streams,

- int unclaimed_streams,

- SpdyGoAwayStatus status,

- NetLogCaptureMode /* capture_mode */) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+scoped_ptr<base::Value> NetLogSpdyGoAwayCallback(

+ SpdyStreamId last_stream_id,

+ int active_streams,

+ int unclaimed_streams,

+ SpdyGoAwayStatus status,

+ NetLogCaptureMode /* capture_mode */) {

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("last_accepted_stream_id",

static_cast<int>(last_stream_id));

dict->SetInteger("active_streams", active_streams);

dict->SetInteger("unclaimed_streams", unclaimed_streams);

dict->SetInteger("status", static_cast<int>(status));

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyPushPromiseReceivedCallback(

+scoped_ptr<base::Value> NetLogSpdyPushPromiseReceivedCallback(

const SpdyHeaderBlock* headers,

SpdyStreamId stream_id,

SpdyStreamId promised_stream_id,

NetLogCaptureMode capture_mode) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->Set("headers", SpdyHeaderBlockToListValue(*headers, capture_mode));

dict->SetInteger("id", stream_id);

dict->SetInteger("promised_stream_id", promised_stream_id);

- return dict;

+ return dict.Pass();

}

-base::Value* NetLogSpdyAdoptedPushStreamCallback(

+scoped_ptr<base::Value> NetLogSpdyAdoptedPushStreamCallback(

SpdyStreamId stream_id,

const GURL* url,

NetLogCaptureMode capture_mode) {

- base::DictionaryValue* dict = new base::DictionaryValue();

+ scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

dict->SetInteger("stream_id", stream_id);

dict->SetString("url", url->spec());

- return dict;

+ return dict.Pass();

}

// Helper function to return the total size of an array of objects

@@ -676,7 +684,7 @@ SpdySession::SpdySession(

DCHECK(HttpStreamFactory::spdy_enabled());

net_log_.BeginEvent(

NetLog::TYPE_HTTP2_SESSION,

- base::Bind(&NetLogSpdySessionCallback, &host_port_proxy_pair()));

+ base::Bind(NetLogSpdySessionCallback, &host_port_proxy_pair()));

next_unclaimed_push_stream_sweep_time_ = time_func_() +

base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);

// TODO(mbelshe): consider randomization of the stream_hi_water_mark.

@@ -753,7 +761,7 @@ void SpdySession::InitializeWithSocket(

net_log_.AddEvent(

NetLog::TYPE_HTTP2_SESSION_INITIALIZED,

- base::Bind(&NetLogSpdyInitializedCallback,

+ base::Bind(NetLogSpdyInitializedCallback,

connection_->socket()->NetLog().source(), protocol_));

DCHECK_EQ(availability_state_, STATE_AVAILABLE);

@@ -1080,7 +1088,7 @@ scoped_ptr<SpdyFrame> SpdySession::CreateSynStream(

? NetLog::TYPE_HTTP2_SESSION_SYN_STREAM

: NetLog::TYPE_HTTP2_SESSION_SEND_HEADERS;

net_log().AddEvent(type,

- base::Bind(&NetLogSpdySynStreamSentCallback, &block,

+ base::Bind(NetLogSpdySynStreamSentCallback, &block,

(flags & CONTROL_FLAG_FIN) != 0,

(flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0,

spdy_priority, stream_id));

@@ -1186,7 +1194,7 @@ scoped_ptr<SpdyBuffer> SpdySession::CreateDataBuffer(SpdyStreamId stream_id,

if (net_log().IsCapturing()) {

net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_SEND_DATA,

- base::Bind(&NetLogSpdyDataCallback, stream_id,

+ base::Bind(NetLogSpdyDataCallback, stream_id,

effective_len, (flags & DATA_FLAG_FIN) != 0));

}

@@ -1327,7 +1335,7 @@ void SpdySession::EnqueueResetStreamFrame(SpdyStreamId stream_id,

net_log().AddEvent(

NetLog::TYPE_HTTP2_SESSION_SEND_RST_STREAM,

- base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));

+ base::Bind(NetLogSpdyRstCallback, stream_id, status, &description));

DCHECK(buffered_spdy_framer_.get());

scoped_ptr<SpdyFrame> rst_frame(

@@ -1728,7 +1736,7 @@ void SpdySession::DoDrainSession(Error err, const std::string& description) {

net_log_.AddEvent(

NetLog::TYPE_HTTP2_SESSION_CLOSE,

- base::Bind(&NetLogSpdySessionCloseCallback, err, &description));

+ base::Bind(NetLogSpdySessionCloseCallback, err, &description));

UMA_HISTOGRAM_SPARSE_SLOWLY("Net.SpdySession.ClosedOnError", -err);

UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySession.BytesRead.OtherErrors",

@@ -1962,7 +1970,7 @@ base::WeakPtr<SpdyStream> SpdySession::GetActivePushStream(const GURL& url) {

}

net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_ADOPTED_PUSH_STREAM,

- base::Bind(&NetLogSpdyAdoptedPushStreamCallback,

+ base::Bind(NetLogSpdyAdoptedPushStreamCallback,

active_it->second.stream->stream_id(), &url));

return active_it->second.stream->GetWeakPtr();

}

@@ -2028,9 +2036,8 @@ void SpdySession::OnStreamFrameData(SpdyStreamId stream_id,

CHECK(in_io_loop_);

DCHECK_LT(len, 1u << 24);

if (net_log().IsCapturing()) {

- net_log().AddEvent(

- NetLog::TYPE_HTTP2_SESSION_RECV_DATA,

- base::Bind(&NetLogSpdyDataCallback, stream_id, len, fin));

+ net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_DATA,

+ base::Bind(NetLogSpdyDataCallback, stream_id, len, fin));

}

// Build the buffer as early as possible so that we go through the

@@ -2102,7 +2109,7 @@ void SpdySession::OnSettings(bool clear_persisted) {

if (net_log_.IsCapturing()) {

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_SETTINGS,

- base::Bind(&NetLogSpdySettingsCallback, host_port_pair(),

+ base::Bind(NetLogSpdySettingsCallback, host_port_pair(),

clear_persisted));

}

@@ -2134,7 +2141,7 @@ void SpdySession::OnSetting(SpdySettingsIds id,

// Log the setting.

const SpdyMajorVersion protocol_version = GetProtocolVersion();

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_SETTING,

- base::Bind(&NetLogSpdySettingCallback, id, protocol_version,

+ base::Bind(NetLogSpdySettingCallback, id, protocol_version,

static_cast<SpdySettingsFlags>(flags), value));

}

@@ -2216,7 +2223,7 @@ void SpdySession::OnSynStream(SpdyStreamId stream_id,

if (net_log_.IsCapturing()) {

net_log_.AddEvent(

NetLog::TYPE_HTTP2_SESSION_PUSHED_SYN_STREAM,

- base::Bind(&NetLogSpdySynStreamReceivedCallback, &headers, fin,

+ base::Bind(NetLogSpdySynStreamReceivedCallback, &headers, fin,

unidirectional, priority, stream_id, associated_stream_id));

}

@@ -2287,7 +2294,7 @@ void SpdySession::OnSynReply(SpdyStreamId stream_id,

if (net_log().IsCapturing()) {

net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_SYN_REPLY,

- base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,

+ base::Bind(NetLogSpdySynReplyOrHeadersReceivedCallback,

&headers, fin, stream_id));

}

@@ -2332,7 +2339,7 @@ void SpdySession::OnHeaders(SpdyStreamId stream_id,

if (net_log().IsCapturing()) {

net_log().AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_HEADERS,

- base::Bind(&NetLogSpdySynReplyOrHeadersReceivedCallback,

+ base::Bind(NetLogSpdySynReplyOrHeadersReceivedCallback,

&headers, fin, stream_id));

}

@@ -2395,7 +2402,7 @@ void SpdySession::OnRstStream(SpdyStreamId stream_id,

std::string description;

net_log().AddEvent(

NetLog::TYPE_HTTP2_SESSION_RST_STREAM,

- base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));

+ base::Bind(NetLogSpdyRstCallback, stream_id, status, &description));

ActiveStreamMap::iterator it = active_streams_.find(stream_id);

if (it == active_streams_.end()) {

@@ -2436,7 +2443,7 @@ void SpdySession::OnGoAway(SpdyStreamId last_accepted_stream_id,

// TODO(jgraettinger): UMA histogram on |status|.

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_GOAWAY,

- base::Bind(&NetLogSpdyGoAwayCallback,

+ base::Bind(NetLogSpdyGoAwayCallback,

last_accepted_stream_id, active_streams_.size(),

unclaimed_pushed_streams_.size(), status));

MakeUnavailable();

@@ -2458,7 +2465,7 @@ void SpdySession::OnPing(SpdyPingId unique_id, bool is_ack) {

net_log_.AddEvent(

NetLog::TYPE_HTTP2_SESSION_PING,

- base::Bind(&NetLogSpdyPingCallback, unique_id, is_ack, "received"));

+ base::Bind(NetLogSpdyPingCallback, unique_id, is_ack, "received"));

// Send response to a PING from server.

if ((protocol_ >= kProtoSPDY4MinimumVersion && !is_ack) ||

@@ -2489,7 +2496,7 @@ void SpdySession::OnWindowUpdate(SpdyStreamId stream_id,

DCHECK_LE(delta_window_size, static_cast<uint32>(kint32max));

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECEIVED_WINDOW_UPDATE_FRAME,

- base::Bind(&NetLogSpdyWindowUpdateFrameCallback, stream_id,

+ base::Bind(NetLogSpdyWindowUpdateFrameCallback, stream_id,

delta_window_size));

if (stream_id == kSessionFlowControlStreamId) {

@@ -2715,7 +2722,7 @@ void SpdySession::OnPushPromise(SpdyStreamId stream_id,

if (net_log_.IsCapturing()) {

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_RECV_PUSH_PROMISE,

- base::Bind(&NetLogSpdyPushPromiseReceivedCallback,

+ base::Bind(NetLogSpdyPushPromiseReceivedCallback,

&headers, stream_id, promised_stream_id));

}

@@ -2809,7 +2816,7 @@ void SpdySession::SendSettings(const SettingsMap& settings) {

const SpdyMajorVersion protocol_version = GetProtocolVersion();

net_log_.AddEvent(

NetLog::TYPE_HTTP2_SESSION_SEND_SETTINGS,

- base::Bind(&NetLogSpdySendSettingsCallback, &settings, protocol_version));

+ base::Bind(NetLogSpdySendSettingsCallback, &settings, protocol_version));

// Create the SETTINGS frame and send it.

DCHECK(buffered_spdy_framer_.get());

scoped_ptr<SpdyFrame> settings_frame(

@@ -2892,7 +2899,7 @@ void SpdySession::SendWindowUpdateFrame(SpdyStreamId stream_id,

}

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_SENT_WINDOW_UPDATE_FRAME,

- base::Bind(&NetLogSpdyWindowUpdateFrameCallback, stream_id,

+ base::Bind(NetLogSpdyWindowUpdateFrameCallback, stream_id,

delta_window_size));

DCHECK(buffered_spdy_framer_.get());

@@ -2910,7 +2917,7 @@ void SpdySession::WritePingFrame(SpdyPingId unique_id, bool is_ack) {

if (net_log().IsCapturing()) {

net_log().AddEvent(

NetLog::TYPE_HTTP2_SESSION_PING,

- base::Bind(&NetLogSpdyPingCallback, unique_id, is_ack, "sent"));

+ base::Bind(NetLogSpdyPingCallback, unique_id, is_ack, "sent"));

}

if (!is_ack) {

next_ping_id_ += 2;

@@ -3119,7 +3126,7 @@ void SpdySession::IncreaseSendWindowSize(int32 delta_window_size) {

session_send_window_size_ += delta_window_size;

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_SEND_WINDOW,

- base::Bind(&NetLogSpdySessionWindowUpdateCallback,

+ base::Bind(NetLogSpdySessionWindowUpdateCallback,

delta_window_size, session_send_window_size_));

DCHECK(!IsSendStalled());

@@ -3141,7 +3148,7 @@ void SpdySession::DecreaseSendWindowSize(int32 delta_window_size) {

session_send_window_size_ -= delta_window_size;

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_SEND_WINDOW,

- base::Bind(&NetLogSpdySessionWindowUpdateCallback,

+ base::Bind(NetLogSpdySessionWindowUpdateCallback,

-delta_window_size, session_send_window_size_));

}

@@ -3168,7 +3175,7 @@ void SpdySession::IncreaseRecvWindowSize(int32 delta_window_size) {

session_recv_window_size_ += delta_window_size;

net_log_.AddEvent(NetLog::TYPE_HTTP2_STREAM_UPDATE_RECV_WINDOW,

- base::Bind(&NetLogSpdySessionWindowUpdateCallback,

+ base::Bind(NetLogSpdySessionWindowUpdateCallback,

delta_window_size, session_recv_window_size_));

session_unacked_recv_window_bytes_ += delta_window_size;

@@ -3202,7 +3209,7 @@ void SpdySession::DecreaseRecvWindowSize(int32 delta_window_size) {

session_recv_window_size_ -= delta_window_size;

net_log_.AddEvent(NetLog::TYPE_HTTP2_SESSION_UPDATE_RECV_WINDOW,

- base::Bind(&NetLogSpdySessionWindowUpdateCallback,

+ base::Bind(NetLogSpdySessionWindowUpdateCallback,

-delta_window_size, session_recv_window_size_));

}

« no previous file with comments | « net/spdy/spdy_http_stream.cc ('k') | net/spdy/spdy_stream.cc » ('j') | no next file with comments »