OLD | NEW |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_stream.h" | 5 #include "net/spdy/spdy_stream.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
9 #include "base/singleton.h" | 9 #include "base/singleton.h" |
10 #include "base/values.h" | 10 #include "base/values.h" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
53 delegate_(NULL), | 53 delegate_(NULL), |
54 request_time_(base::Time::Now()), | 54 request_time_(base::Time::Now()), |
55 response_(new spdy::SpdyHeaderBlock), | 55 response_(new spdy::SpdyHeaderBlock), |
56 io_state_(STATE_NONE), | 56 io_state_(STATE_NONE), |
57 response_status_(OK), | 57 response_status_(OK), |
58 cancelled_(false), | 58 cancelled_(false), |
59 has_upload_data_(false), | 59 has_upload_data_(false), |
60 net_log_(net_log), | 60 net_log_(net_log), |
61 send_bytes_(0), | 61 send_bytes_(0), |
62 recv_bytes_(0) { | 62 recv_bytes_(0) { |
63 net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM, | 63 net_log_.BeginEvent( |
64 new NetLogIntegerParameter("stream_id", stream_id_)); | 64 NetLog::TYPE_SPDY_STREAM, |
| 65 make_scoped_refptr(new NetLogIntegerParameter("stream_id", stream_id_))); |
65 } | 66 } |
66 | 67 |
67 SpdyStream::~SpdyStream() { | 68 SpdyStream::~SpdyStream() { |
68 UpdateHistograms(); | 69 UpdateHistograms(); |
69 net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM, NULL); | 70 net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM, NULL); |
70 } | 71 } |
71 | 72 |
72 void SpdyStream::SetDelegate(Delegate* delegate) { | 73 void SpdyStream::SetDelegate(Delegate* delegate) { |
73 CHECK(delegate); | 74 CHECK(delegate); |
74 delegate_ = delegate; | 75 delegate_ = delegate; |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
141 LOG(WARNING) << "Received WINDOW_UPDATE [delta:" << delta_window_size | 142 LOG(WARNING) << "Received WINDOW_UPDATE [delta:" << delta_window_size |
142 << "] for stream " << stream_id_ | 143 << "] for stream " << stream_id_ |
143 << " overflows send_window_size_ [current:" | 144 << " overflows send_window_size_ [current:" |
144 << send_window_size_ << "]"; | 145 << send_window_size_ << "]"; |
145 session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR); | 146 session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR); |
146 return; | 147 return; |
147 } | 148 } |
148 | 149 |
149 send_window_size_ = new_window_size; | 150 send_window_size_ = new_window_size; |
150 | 151 |
151 net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE, | 152 net_log_.AddEvent( |
152 new NetLogSpdyStreamWindowUpdateParameter(stream_id_, | 153 NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE, |
153 delta_window_size, send_window_size_)); | 154 make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter( |
| 155 stream_id_, delta_window_size, send_window_size_))); |
154 if (stalled_by_flow_control_) { | 156 if (stalled_by_flow_control_) { |
155 stalled_by_flow_control_ = false; | 157 stalled_by_flow_control_ = false; |
156 io_state_ = STATE_SEND_BODY; | 158 io_state_ = STATE_SEND_BODY; |
157 DoLoop(OK); | 159 DoLoop(OK); |
158 } | 160 } |
159 } | 161 } |
160 | 162 |
161 void SpdyStream::DecreaseSendWindowSize(int delta_window_size) { | 163 void SpdyStream::DecreaseSendWindowSize(int delta_window_size) { |
162 // we only call this method when sending a frame, therefore | 164 // we only call this method when sending a frame, therefore |
163 // |delta_window_size| should be within the valid frame size range. | 165 // |delta_window_size| should be within the valid frame size range. |
164 DCHECK_GE(delta_window_size, 1); | 166 DCHECK_GE(delta_window_size, 1); |
165 DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize); | 167 DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize); |
166 | 168 |
167 // |send_window_size_| should have been at least |delta_window_size| for | 169 // |send_window_size_| should have been at least |delta_window_size| for |
168 // this call to happen. | 170 // this call to happen. |
169 DCHECK_GE(send_window_size_, delta_window_size); | 171 DCHECK_GE(send_window_size_, delta_window_size); |
170 | 172 |
171 send_window_size_ -= delta_window_size; | 173 send_window_size_ -= delta_window_size; |
172 | 174 |
173 net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE, | 175 net_log_.AddEvent( |
174 new NetLogSpdyStreamWindowUpdateParameter(stream_id_, | 176 NetLog::TYPE_SPDY_STREAM_SEND_WINDOW_UPDATE, |
175 -delta_window_size, send_window_size_)); | 177 make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter( |
| 178 stream_id_, -delta_window_size, send_window_size_))); |
176 } | 179 } |
177 | 180 |
178 void SpdyStream::IncreaseRecvWindowSize(int delta_window_size) { | 181 void SpdyStream::IncreaseRecvWindowSize(int delta_window_size) { |
179 DCHECK_GE(delta_window_size, 1); | 182 DCHECK_GE(delta_window_size, 1); |
180 // By the time a read is isued, stream may become inactive. | 183 // By the time a read is isued, stream may become inactive. |
181 if (!session_->IsStreamActive(stream_id_)) | 184 if (!session_->IsStreamActive(stream_id_)) |
182 return; | 185 return; |
183 int new_window_size = recv_window_size_ + delta_window_size; | 186 int new_window_size = recv_window_size_ + delta_window_size; |
184 if (recv_window_size_ > 0) | 187 if (recv_window_size_ > 0) |
185 DCHECK(new_window_size > 0); | 188 DCHECK(new_window_size > 0); |
186 | 189 |
187 recv_window_size_ = new_window_size; | 190 recv_window_size_ = new_window_size; |
188 net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE, | 191 net_log_.AddEvent( |
189 new NetLogSpdyStreamWindowUpdateParameter(stream_id_, | 192 NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE, |
190 delta_window_size, recv_window_size_)); | 193 make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter( |
| 194 stream_id_, delta_window_size, recv_window_size_))); |
191 session_->SendWindowUpdate(stream_id_, delta_window_size); | 195 session_->SendWindowUpdate(stream_id_, delta_window_size); |
192 } | 196 } |
193 | 197 |
194 void SpdyStream::DecreaseRecvWindowSize(int delta_window_size) { | 198 void SpdyStream::DecreaseRecvWindowSize(int delta_window_size) { |
195 DCHECK_GE(delta_window_size, 1); | 199 DCHECK_GE(delta_window_size, 1); |
196 | 200 |
197 recv_window_size_ -= delta_window_size; | 201 recv_window_size_ -= delta_window_size; |
198 net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE, | 202 net_log_.AddEvent( |
199 new NetLogSpdyStreamWindowUpdateParameter(stream_id_, | 203 NetLog::TYPE_SPDY_STREAM_RECV_WINDOW_UPDATE, |
200 -delta_window_size, recv_window_size_)); | 204 make_scoped_refptr(new NetLogSpdyStreamWindowUpdateParameter( |
| 205 stream_id_, -delta_window_size, recv_window_size_))); |
201 | 206 |
202 // Since we never decrease the initial window size, we should never hit | 207 // Since we never decrease the initial window size, we should never hit |
203 // a negative |recv_window_size_|, if we do, it's a flow-control violation. | 208 // a negative |recv_window_size_|, if we do, it's a flow-control violation. |
204 if (recv_window_size_ < 0) | 209 if (recv_window_size_ < 0) |
205 session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR); | 210 session_->ResetStream(stream_id_, spdy::FLOW_CONTROL_ERROR); |
206 } | 211 } |
207 | 212 |
208 int SpdyStream::GetPeerAddress(AddressList* address) const { | 213 int SpdyStream::GetPeerAddress(AddressList* address) const { |
209 return session_->GetPeerAddress(address); | 214 return session_->GetPeerAddress(address); |
210 } | 215 } |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 | 255 |
251 void SpdyStream::OnDataReceived(const char* data, int length) { | 256 void SpdyStream::OnDataReceived(const char* data, int length) { |
252 DCHECK_GE(length, 0); | 257 DCHECK_GE(length, 0); |
253 | 258 |
254 if (!delegate_ || continue_buffering_data_) { | 259 if (!delegate_ || continue_buffering_data_) { |
255 // It should be valid for this to happen in the server push case. | 260 // It should be valid for this to happen in the server push case. |
256 // We'll return received data when delegate gets attached to the stream. | 261 // We'll return received data when delegate gets attached to the stream. |
257 if (length > 0) { | 262 if (length > 0) { |
258 IOBufferWithSize* buf = new IOBufferWithSize(length); | 263 IOBufferWithSize* buf = new IOBufferWithSize(length); |
259 memcpy(buf->data(), data, length); | 264 memcpy(buf->data(), data, length); |
260 pending_buffers_.push_back(buf); | 265 pending_buffers_.push_back(make_scoped_refptr(buf)); |
261 } else { | 266 } else { |
262 pending_buffers_.push_back(NULL); | 267 pending_buffers_.push_back(NULL); |
263 metrics_.StopStream(); | 268 metrics_.StopStream(); |
264 // Note: we leave the stream open in the session until the stream | 269 // Note: we leave the stream open in the session until the stream |
265 // is claimed. | 270 // is claimed. |
266 } | 271 } |
267 return; | 272 return; |
268 } | 273 } |
269 | 274 |
270 CHECK(!closed()); | 275 CHECK(!closed()); |
(...skipping 20 matching lines...) Expand all Loading... |
291 // Track our bandwidth. | 296 // Track our bandwidth. |
292 metrics_.RecordBytes(length); | 297 metrics_.RecordBytes(length); |
293 recv_bytes_ += length; | 298 recv_bytes_ += length; |
294 recv_last_byte_time_ = base::TimeTicks::Now(); | 299 recv_last_byte_time_ = base::TimeTicks::Now(); |
295 | 300 |
296 if (!delegate_) { | 301 if (!delegate_) { |
297 // It should be valid for this to happen in the server push case. | 302 // It should be valid for this to happen in the server push case. |
298 // We'll return received data when delegate gets attached to the stream. | 303 // We'll return received data when delegate gets attached to the stream. |
299 IOBufferWithSize* buf = new IOBufferWithSize(length); | 304 IOBufferWithSize* buf = new IOBufferWithSize(length); |
300 memcpy(buf->data(), data, length); | 305 memcpy(buf->data(), data, length); |
301 pending_buffers_.push_back(buf); | 306 pending_buffers_.push_back(make_scoped_refptr(buf)); |
302 return; | 307 return; |
303 } | 308 } |
304 | 309 |
305 delegate_->OnDataReceived(data, length); | 310 delegate_->OnDataReceived(data, length); |
306 } | 311 } |
307 | 312 |
308 // This function is only called when an entire frame is written. | 313 // This function is only called when an entire frame is written. |
309 void SpdyStream::OnWriteComplete(int bytes) { | 314 void SpdyStream::OnWriteComplete(int bytes) { |
310 DCHECK_LE(0, bytes); | 315 DCHECK_LE(0, bytes); |
311 send_bytes_ += bytes; | 316 send_bytes_ += bytes; |
(...skipping 193 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
505 UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime", | 510 UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime", |
506 recv_last_byte_time_ - recv_first_byte_time_); | 511 recv_last_byte_time_ - recv_first_byte_time_); |
507 UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime", | 512 UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime", |
508 recv_last_byte_time_ - send_time_); | 513 recv_last_byte_time_ - send_time_); |
509 | 514 |
510 UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_); | 515 UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_); |
511 UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_); | 516 UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_); |
512 } | 517 } |
513 | 518 |
514 } // namespace net | 519 } // namespace net |
OLD | NEW |