| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/spdy/spdy_stream.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/compiler_specific.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/message_loop/message_loop.h" | |
| 11 #include "base/profiler/scoped_tracker.h" | |
| 12 #include "base/strings/string_number_conversions.h" | |
| 13 #include "base/strings/stringprintf.h" | |
| 14 #include "base/values.h" | |
| 15 #include "net/spdy/spdy_buffer_producer.h" | |
| 16 #include "net/spdy/spdy_http_utils.h" | |
| 17 #include "net/spdy/spdy_session.h" | |
| 18 | |
| 19 namespace net { | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 base::Value* NetLogSpdyStreamErrorCallback(SpdyStreamId stream_id, | |
| 24 int status, | |
| 25 const std::string* description, | |
| 26 NetLog::LogLevel /* log_level */) { | |
| 27 base::DictionaryValue* dict = new base::DictionaryValue(); | |
| 28 dict->SetInteger("stream_id", static_cast<int>(stream_id)); | |
| 29 dict->SetInteger("status", status); | |
| 30 dict->SetString("description", *description); | |
| 31 return dict; | |
| 32 } | |
| 33 | |
| 34 base::Value* NetLogSpdyStreamWindowUpdateCallback( | |
| 35 SpdyStreamId stream_id, | |
| 36 int32 delta, | |
| 37 int32 window_size, | |
| 38 NetLog::LogLevel /* log_level */) { | |
| 39 base::DictionaryValue* dict = new base::DictionaryValue(); | |
| 40 dict->SetInteger("stream_id", stream_id); | |
| 41 dict->SetInteger("delta", delta); | |
| 42 dict->SetInteger("window_size", window_size); | |
| 43 return dict; | |
| 44 } | |
| 45 | |
| 46 bool ContainsUppercaseAscii(const std::string& str) { | |
| 47 for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) { | |
| 48 if (*i >= 'A' && *i <= 'Z') { | |
| 49 return true; | |
| 50 } | |
| 51 } | |
| 52 return false; | |
| 53 } | |
| 54 | |
| 55 } // namespace | |
| 56 | |
| 57 // A wrapper around a stream that calls into ProduceSynStreamFrame(). | |
| 58 class SpdyStream::SynStreamBufferProducer : public SpdyBufferProducer { | |
| 59 public: | |
| 60 SynStreamBufferProducer(const base::WeakPtr<SpdyStream>& stream) | |
| 61 : stream_(stream) { | |
| 62 DCHECK(stream_.get()); | |
| 63 } | |
| 64 | |
| 65 ~SynStreamBufferProducer() override {} | |
| 66 | |
| 67 scoped_ptr<SpdyBuffer> ProduceBuffer() override { | |
| 68 if (!stream_.get()) { | |
| 69 NOTREACHED(); | |
| 70 return scoped_ptr<SpdyBuffer>(); | |
| 71 } | |
| 72 DCHECK_GT(stream_->stream_id(), 0u); | |
| 73 return scoped_ptr<SpdyBuffer>( | |
| 74 new SpdyBuffer(stream_->ProduceSynStreamFrame())); | |
| 75 } | |
| 76 | |
| 77 private: | |
| 78 const base::WeakPtr<SpdyStream> stream_; | |
| 79 }; | |
| 80 | |
| 81 SpdyStream::SpdyStream(SpdyStreamType type, | |
| 82 const base::WeakPtr<SpdySession>& session, | |
| 83 const GURL& url, | |
| 84 RequestPriority priority, | |
| 85 int32 initial_send_window_size, | |
| 86 int32 initial_recv_window_size, | |
| 87 const BoundNetLog& net_log) | |
| 88 : type_(type), | |
| 89 stream_id_(0), | |
| 90 url_(url), | |
| 91 priority_(priority), | |
| 92 send_stalled_by_flow_control_(false), | |
| 93 send_window_size_(initial_send_window_size), | |
| 94 recv_window_size_(initial_recv_window_size), | |
| 95 unacked_recv_window_bytes_(0), | |
| 96 session_(session), | |
| 97 delegate_(NULL), | |
| 98 pending_send_status_(MORE_DATA_TO_SEND), | |
| 99 request_time_(base::Time::Now()), | |
| 100 response_headers_status_(RESPONSE_HEADERS_ARE_INCOMPLETE), | |
| 101 io_state_(STATE_IDLE), | |
| 102 response_status_(OK), | |
| 103 net_log_(net_log), | |
| 104 raw_received_bytes_(0), | |
| 105 send_bytes_(0), | |
| 106 recv_bytes_(0), | |
| 107 write_handler_guard_(false), | |
| 108 weak_ptr_factory_(this) { | |
| 109 CHECK(type_ == SPDY_BIDIRECTIONAL_STREAM || | |
| 110 type_ == SPDY_REQUEST_RESPONSE_STREAM || | |
| 111 type_ == SPDY_PUSH_STREAM); | |
| 112 CHECK_GE(priority_, MINIMUM_PRIORITY); | |
| 113 CHECK_LE(priority_, MAXIMUM_PRIORITY); | |
| 114 } | |
| 115 | |
| 116 SpdyStream::~SpdyStream() { | |
| 117 CHECK(!write_handler_guard_); | |
| 118 UpdateHistograms(); | |
| 119 } | |
| 120 | |
| 121 void SpdyStream::SetDelegate(Delegate* delegate) { | |
| 122 CHECK(!delegate_); | |
| 123 CHECK(delegate); | |
| 124 delegate_ = delegate; | |
| 125 | |
| 126 CHECK(io_state_ == STATE_IDLE || | |
| 127 io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED || | |
| 128 io_state_ == STATE_RESERVED_REMOTE); | |
| 129 | |
| 130 if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) { | |
| 131 DCHECK_EQ(type_, SPDY_PUSH_STREAM); | |
| 132 base::MessageLoop::current()->PostTask( | |
| 133 FROM_HERE, | |
| 134 base::Bind(&SpdyStream::PushedStreamReplay, GetWeakPtr())); | |
| 135 } | |
| 136 } | |
| 137 | |
| 138 void SpdyStream::PushedStreamReplay() { | |
| 139 DCHECK_EQ(type_, SPDY_PUSH_STREAM); | |
| 140 DCHECK_NE(stream_id_, 0u); | |
| 141 CHECK_EQ(stream_id_ % 2, 0u); | |
| 142 | |
| 143 CHECK_EQ(io_state_, STATE_HALF_CLOSED_LOCAL_UNCLAIMED); | |
| 144 io_state_ = STATE_HALF_CLOSED_LOCAL; | |
| 145 | |
| 146 // The delegate methods called below may delete |this|, so use | |
| 147 // |weak_this| to detect that. | |
| 148 base::WeakPtr<SpdyStream> weak_this = GetWeakPtr(); | |
| 149 | |
| 150 CHECK(delegate_); | |
| 151 SpdyResponseHeadersStatus status = | |
| 152 delegate_->OnResponseHeadersUpdated(response_headers_); | |
| 153 if (status == RESPONSE_HEADERS_ARE_INCOMPLETE) { | |
| 154 // Since RESPONSE_HEADERS_ARE_INCOMPLETE was returned, we must not | |
| 155 // have been closed. Since we don't have complete headers, assume | |
| 156 // we're waiting for another HEADERS frame, and we had better not | |
| 157 // have any pending data frames. | |
| 158 CHECK(weak_this); | |
| 159 if (!pending_recv_data_.empty()) { | |
| 160 LogStreamError(ERR_SPDY_PROTOCOL_ERROR, | |
| 161 "Data received with incomplete headers."); | |
| 162 session_->CloseActiveStream(stream_id_, ERR_SPDY_PROTOCOL_ERROR); | |
| 163 } | |
| 164 return; | |
| 165 } | |
| 166 | |
| 167 // OnResponseHeadersUpdated() may have closed |this|. | |
| 168 if (!weak_this) | |
| 169 return; | |
| 170 | |
| 171 response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE; | |
| 172 | |
| 173 while (!pending_recv_data_.empty()) { | |
| 174 // Take ownership of the first element of |pending_recv_data_|. | |
| 175 scoped_ptr<SpdyBuffer> buffer(pending_recv_data_.front()); | |
| 176 pending_recv_data_.weak_erase(pending_recv_data_.begin()); | |
| 177 | |
| 178 bool eof = (buffer == NULL); | |
| 179 | |
| 180 CHECK(delegate_); | |
| 181 delegate_->OnDataReceived(buffer.Pass()); | |
| 182 | |
| 183 // OnDataReceived() may have closed |this|. | |
| 184 if (!weak_this) | |
| 185 return; | |
| 186 | |
| 187 if (eof) { | |
| 188 DCHECK(pending_recv_data_.empty()); | |
| 189 session_->CloseActiveStream(stream_id_, OK); | |
| 190 DCHECK(!weak_this); | |
| 191 // |pending_recv_data_| is invalid at this point. | |
| 192 break; | |
| 193 } | |
| 194 } | |
| 195 } | |
| 196 | |
| 197 scoped_ptr<SpdyFrame> SpdyStream::ProduceSynStreamFrame() { | |
| 198 CHECK_EQ(io_state_, STATE_IDLE); | |
| 199 CHECK(request_headers_); | |
| 200 CHECK_GT(stream_id_, 0u); | |
| 201 | |
| 202 SpdyControlFlags flags = | |
| 203 (pending_send_status_ == NO_MORE_DATA_TO_SEND) ? | |
| 204 CONTROL_FLAG_FIN : CONTROL_FLAG_NONE; | |
| 205 scoped_ptr<SpdyFrame> frame(session_->CreateSynStream( | |
| 206 stream_id_, priority_, flags, *request_headers_)); | |
| 207 send_time_ = base::TimeTicks::Now(); | |
| 208 return frame.Pass(); | |
| 209 } | |
| 210 | |
| 211 void SpdyStream::DetachDelegate() { | |
| 212 DCHECK(!IsClosed()); | |
| 213 delegate_ = NULL; | |
| 214 Cancel(); | |
| 215 } | |
| 216 | |
| 217 void SpdyStream::AdjustSendWindowSize(int32 delta_window_size) { | |
| 218 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 219 | |
| 220 if (IsClosed()) | |
| 221 return; | |
| 222 | |
| 223 // Check for wraparound. | |
| 224 if (send_window_size_ > 0) { | |
| 225 DCHECK_LE(delta_window_size, kint32max - send_window_size_); | |
| 226 } | |
| 227 if (send_window_size_ < 0) { | |
| 228 DCHECK_GE(delta_window_size, kint32min - send_window_size_); | |
| 229 } | |
| 230 send_window_size_ += delta_window_size; | |
| 231 PossiblyResumeIfSendStalled(); | |
| 232 } | |
| 233 | |
| 234 void SpdyStream::OnWriteBufferConsumed( | |
| 235 size_t frame_payload_size, | |
| 236 size_t consume_size, | |
| 237 SpdyBuffer::ConsumeSource consume_source) { | |
| 238 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 239 if (consume_source == SpdyBuffer::DISCARD) { | |
| 240 // If we're discarding a frame or part of it, increase the send | |
| 241 // window by the number of discarded bytes. (Although if we're | |
| 242 // discarding part of a frame, it's probably because of a write | |
| 243 // error and we'll be tearing down the stream soon.) | |
| 244 size_t remaining_payload_bytes = std::min(consume_size, frame_payload_size); | |
| 245 DCHECK_GT(remaining_payload_bytes, 0u); | |
| 246 IncreaseSendWindowSize(static_cast<int32>(remaining_payload_bytes)); | |
| 247 } | |
| 248 // For consumed bytes, the send window is increased when we receive | |
| 249 // a WINDOW_UPDATE frame. | |
| 250 } | |
| 251 | |
| 252 void SpdyStream::IncreaseSendWindowSize(int32 delta_window_size) { | |
| 253 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 254 DCHECK_GE(delta_window_size, 1); | |
| 255 | |
| 256 // Ignore late WINDOW_UPDATEs. | |
| 257 if (IsClosed()) | |
| 258 return; | |
| 259 | |
| 260 if (send_window_size_ > 0) { | |
| 261 // Check for overflow. | |
| 262 int32 max_delta_window_size = kint32max - send_window_size_; | |
| 263 if (delta_window_size > max_delta_window_size) { | |
| 264 std::string desc = base::StringPrintf( | |
| 265 "Received WINDOW_UPDATE [delta: %d] for stream %d overflows " | |
| 266 "send_window_size_ [current: %d]", delta_window_size, stream_id_, | |
| 267 send_window_size_); | |
| 268 session_->ResetStream(stream_id_, RST_STREAM_FLOW_CONTROL_ERROR, desc); | |
| 269 return; | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 send_window_size_ += delta_window_size; | |
| 274 | |
| 275 net_log_.AddEvent( | |
| 276 NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW, | |
| 277 base::Bind(&NetLogSpdyStreamWindowUpdateCallback, | |
| 278 stream_id_, delta_window_size, send_window_size_)); | |
| 279 | |
| 280 PossiblyResumeIfSendStalled(); | |
| 281 } | |
| 282 | |
| 283 void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) { | |
| 284 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 285 | |
| 286 if (IsClosed()) | |
| 287 return; | |
| 288 | |
| 289 // We only call this method when sending a frame. Therefore, | |
| 290 // |delta_window_size| should be within the valid frame size range. | |
| 291 DCHECK_GE(delta_window_size, 1); | |
| 292 DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize); | |
| 293 | |
| 294 // |send_window_size_| should have been at least |delta_window_size| for | |
| 295 // this call to happen. | |
| 296 DCHECK_GE(send_window_size_, delta_window_size); | |
| 297 | |
| 298 send_window_size_ -= delta_window_size; | |
| 299 | |
| 300 net_log_.AddEvent( | |
| 301 NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW, | |
| 302 base::Bind(&NetLogSpdyStreamWindowUpdateCallback, | |
| 303 stream_id_, -delta_window_size, send_window_size_)); | |
| 304 } | |
| 305 | |
| 306 void SpdyStream::OnReadBufferConsumed( | |
| 307 size_t consume_size, | |
| 308 SpdyBuffer::ConsumeSource consume_source) { | |
| 309 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 310 DCHECK_GE(consume_size, 1u); | |
| 311 DCHECK_LE(consume_size, static_cast<size_t>(kint32max)); | |
| 312 IncreaseRecvWindowSize(static_cast<int32>(consume_size)); | |
| 313 } | |
| 314 | |
| 315 void SpdyStream::IncreaseRecvWindowSize(int32 delta_window_size) { | |
| 316 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 317 | |
| 318 // By the time a read is processed by the delegate, this stream may | |
| 319 // already be inactive. | |
| 320 if (!session_->IsStreamActive(stream_id_)) | |
| 321 return; | |
| 322 | |
| 323 DCHECK_GE(unacked_recv_window_bytes_, 0); | |
| 324 DCHECK_GE(recv_window_size_, unacked_recv_window_bytes_); | |
| 325 DCHECK_GE(delta_window_size, 1); | |
| 326 // Check for overflow. | |
| 327 DCHECK_LE(delta_window_size, kint32max - recv_window_size_); | |
| 328 | |
| 329 recv_window_size_ += delta_window_size; | |
| 330 net_log_.AddEvent( | |
| 331 NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW, | |
| 332 base::Bind(&NetLogSpdyStreamWindowUpdateCallback, | |
| 333 stream_id_, delta_window_size, recv_window_size_)); | |
| 334 | |
| 335 unacked_recv_window_bytes_ += delta_window_size; | |
| 336 if (unacked_recv_window_bytes_ > | |
| 337 session_->stream_initial_recv_window_size() / 2) { | |
| 338 session_->SendStreamWindowUpdate( | |
| 339 stream_id_, static_cast<uint32>(unacked_recv_window_bytes_)); | |
| 340 unacked_recv_window_bytes_ = 0; | |
| 341 } | |
| 342 } | |
| 343 | |
| 344 void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) { | |
| 345 DCHECK(session_->IsStreamActive(stream_id_)); | |
| 346 DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM); | |
| 347 DCHECK_GE(delta_window_size, 1); | |
| 348 | |
| 349 // Since we never decrease the initial receive window size, | |
| 350 // |delta_window_size| should never cause |recv_window_size_| to go | |
| 351 // negative. If we do, the receive window isn't being respected. | |
| 352 if (delta_window_size > recv_window_size_) { | |
| 353 session_->ResetStream( | |
| 354 stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 355 "delta_window_size is " + base::IntToString(delta_window_size) + | |
| 356 " in DecreaseRecvWindowSize, which is larger than the receive " + | |
| 357 "window size of " + base::IntToString(recv_window_size_)); | |
| 358 return; | |
| 359 } | |
| 360 | |
| 361 recv_window_size_ -= delta_window_size; | |
| 362 net_log_.AddEvent( | |
| 363 NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW, | |
| 364 base::Bind(&NetLogSpdyStreamWindowUpdateCallback, | |
| 365 stream_id_, -delta_window_size, recv_window_size_)); | |
| 366 } | |
| 367 | |
| 368 int SpdyStream::GetPeerAddress(IPEndPoint* address) const { | |
| 369 return session_->GetPeerAddress(address); | |
| 370 } | |
| 371 | |
| 372 int SpdyStream::GetLocalAddress(IPEndPoint* address) const { | |
| 373 return session_->GetLocalAddress(address); | |
| 374 } | |
| 375 | |
| 376 bool SpdyStream::WasEverUsed() const { | |
| 377 return session_->WasEverUsed(); | |
| 378 } | |
| 379 | |
| 380 base::Time SpdyStream::GetRequestTime() const { | |
| 381 return request_time_; | |
| 382 } | |
| 383 | |
| 384 void SpdyStream::SetRequestTime(base::Time t) { | |
| 385 request_time_ = t; | |
| 386 } | |
| 387 | |
| 388 int SpdyStream::OnInitialResponseHeadersReceived( | |
| 389 const SpdyHeaderBlock& initial_response_headers, | |
| 390 base::Time response_time, | |
| 391 base::TimeTicks recv_first_byte_time) { | |
| 392 // SpdySession guarantees that this is called at most once. | |
| 393 CHECK(response_headers_.empty()); | |
| 394 | |
| 395 // Check to make sure that we don't receive the response headers | |
| 396 // before we're ready for it. | |
| 397 switch (type_) { | |
| 398 case SPDY_BIDIRECTIONAL_STREAM: | |
| 399 // For a bidirectional stream, we're ready for the response | |
| 400 // headers once we've finished sending the request headers. | |
| 401 if (io_state_ == STATE_IDLE) { | |
| 402 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 403 "Response received before request sent"); | |
| 404 return ERR_SPDY_PROTOCOL_ERROR; | |
| 405 } | |
| 406 break; | |
| 407 | |
| 408 case SPDY_REQUEST_RESPONSE_STREAM: | |
| 409 // For a request/response stream, we're ready for the response | |
| 410 // headers once we've finished sending the request headers. | |
| 411 if (io_state_ == STATE_IDLE) { | |
| 412 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 413 "Response received before request sent"); | |
| 414 return ERR_SPDY_PROTOCOL_ERROR; | |
| 415 } | |
| 416 break; | |
| 417 | |
| 418 case SPDY_PUSH_STREAM: | |
| 419 // Push streams transition to a locally half-closed state upon headers. | |
| 420 // We must continue to buffer data while waiting for a call to | |
| 421 // SetDelegate() (which may not ever happen). | |
| 422 CHECK_EQ(io_state_, STATE_RESERVED_REMOTE); | |
| 423 if (!delegate_) { | |
| 424 io_state_ = STATE_HALF_CLOSED_LOCAL_UNCLAIMED; | |
| 425 } else { | |
| 426 io_state_ = STATE_HALF_CLOSED_LOCAL; | |
| 427 } | |
| 428 break; | |
| 429 } | |
| 430 | |
| 431 metrics_.StartStream(); | |
| 432 | |
| 433 DCHECK_NE(io_state_, STATE_IDLE); | |
| 434 | |
| 435 response_time_ = response_time; | |
| 436 recv_first_byte_time_ = recv_first_byte_time; | |
| 437 return MergeWithResponseHeaders(initial_response_headers); | |
| 438 } | |
| 439 | |
| 440 int SpdyStream::OnAdditionalResponseHeadersReceived( | |
| 441 const SpdyHeaderBlock& additional_response_headers) { | |
| 442 if (type_ == SPDY_REQUEST_RESPONSE_STREAM) { | |
| 443 session_->ResetStream( | |
| 444 stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 445 "Additional headers received for request/response stream"); | |
| 446 return ERR_SPDY_PROTOCOL_ERROR; | |
| 447 } else if (type_ == SPDY_PUSH_STREAM && | |
| 448 response_headers_status_ == RESPONSE_HEADERS_ARE_COMPLETE) { | |
| 449 session_->ResetStream( | |
| 450 stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 451 "Additional headers received for push stream"); | |
| 452 return ERR_SPDY_PROTOCOL_ERROR; | |
| 453 } | |
| 454 return MergeWithResponseHeaders(additional_response_headers); | |
| 455 } | |
| 456 | |
| 457 void SpdyStream::OnPushPromiseHeadersReceived(const SpdyHeaderBlock& headers) { | |
| 458 CHECK(!request_headers_.get()); | |
| 459 CHECK_EQ(io_state_, STATE_IDLE); | |
| 460 CHECK_EQ(type_, SPDY_PUSH_STREAM); | |
| 461 DCHECK(!delegate_); | |
| 462 | |
| 463 io_state_ = STATE_RESERVED_REMOTE; | |
| 464 request_headers_.reset(new SpdyHeaderBlock(headers)); | |
| 465 } | |
| 466 | |
| 467 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) { | |
| 468 DCHECK(session_->IsStreamActive(stream_id_)); | |
| 469 | |
| 470 // If we're still buffering data for a push stream, we will do the | |
| 471 // check for data received with incomplete headers in | |
| 472 // PushedStreamReplayData(). | |
| 473 if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) { | |
| 474 DCHECK_EQ(type_, SPDY_PUSH_STREAM); | |
| 475 // It should be valid for this to happen in the server push case. | |
| 476 // We'll return received data when delegate gets attached to the stream. | |
| 477 if (buffer) { | |
| 478 pending_recv_data_.push_back(buffer.release()); | |
| 479 } else { | |
| 480 pending_recv_data_.push_back(NULL); | |
| 481 metrics_.StopStream(); | |
| 482 // Note: we leave the stream open in the session until the stream | |
| 483 // is claimed. | |
| 484 } | |
| 485 return; | |
| 486 } | |
| 487 | |
| 488 // If we have response headers but the delegate has indicated that | |
| 489 // it's still incomplete, then that's a protocol error. | |
| 490 if (response_headers_status_ == RESPONSE_HEADERS_ARE_INCOMPLETE) { | |
| 491 LogStreamError(ERR_SPDY_PROTOCOL_ERROR, | |
| 492 "Data received with incomplete headers."); | |
| 493 session_->CloseActiveStream(stream_id_, ERR_SPDY_PROTOCOL_ERROR); | |
| 494 return; | |
| 495 } | |
| 496 | |
| 497 CHECK(!IsClosed()); | |
| 498 | |
| 499 if (!buffer) { | |
| 500 metrics_.StopStream(); | |
| 501 if (io_state_ == STATE_OPEN) { | |
| 502 io_state_ = STATE_HALF_CLOSED_REMOTE; | |
| 503 } else if (io_state_ == STATE_HALF_CLOSED_LOCAL) { | |
| 504 io_state_ = STATE_CLOSED; | |
| 505 // Deletes |this|. | |
| 506 session_->CloseActiveStream(stream_id_, OK); | |
| 507 } else { | |
| 508 NOTREACHED() << io_state_; | |
| 509 } | |
| 510 return; | |
| 511 } | |
| 512 | |
| 513 size_t length = buffer->GetRemainingSize(); | |
| 514 DCHECK_LE(length, session_->GetDataFrameMaximumPayload()); | |
| 515 if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) { | |
| 516 DecreaseRecvWindowSize(static_cast<int32>(length)); | |
| 517 buffer->AddConsumeCallback( | |
| 518 base::Bind(&SpdyStream::OnReadBufferConsumed, GetWeakPtr())); | |
| 519 } | |
| 520 | |
| 521 // Track our bandwidth. | |
| 522 metrics_.RecordBytes(length); | |
| 523 recv_bytes_ += length; | |
| 524 recv_last_byte_time_ = base::TimeTicks::Now(); | |
| 525 | |
| 526 // May close |this|. | |
| 527 delegate_->OnDataReceived(buffer.Pass()); | |
| 528 } | |
| 529 | |
| 530 void SpdyStream::OnFrameWriteComplete(SpdyFrameType frame_type, | |
| 531 size_t frame_size) { | |
| 532 // TODO(pkasting): Remove ScopedTracker below once crbug.com/457517 is fixed. | |
| 533 tracked_objects::ScopedTracker tracking_profile( | |
| 534 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 535 "457517 SpdyStream::OnFrameWriteComplete")); | |
| 536 DCHECK_NE(type_, SPDY_PUSH_STREAM); | |
| 537 | |
| 538 if (frame_size < session_->GetFrameMinimumSize() || | |
| 539 frame_size > session_->GetFrameMaximumSize()) { | |
| 540 NOTREACHED(); | |
| 541 return; | |
| 542 } | |
| 543 CHECK(frame_type == SYN_STREAM || | |
| 544 frame_type == DATA) << frame_type; | |
| 545 | |
| 546 int result = (frame_type == SYN_STREAM) ? | |
| 547 OnRequestHeadersSent() : OnDataSent(frame_size); | |
| 548 if (result == ERR_IO_PENDING) { | |
| 549 // The write operation hasn't completed yet. | |
| 550 return; | |
| 551 } | |
| 552 | |
| 553 if (pending_send_status_ == NO_MORE_DATA_TO_SEND) { | |
| 554 if(io_state_ == STATE_OPEN) { | |
| 555 io_state_ = STATE_HALF_CLOSED_LOCAL; | |
| 556 } else if(io_state_ == STATE_HALF_CLOSED_REMOTE) { | |
| 557 io_state_ = STATE_CLOSED; | |
| 558 } else { | |
| 559 NOTREACHED() << io_state_; | |
| 560 } | |
| 561 } | |
| 562 // Notify delegate of write completion. Must not destroy |this|. | |
| 563 CHECK(delegate_); | |
| 564 { | |
| 565 base::WeakPtr<SpdyStream> weak_this = GetWeakPtr(); | |
| 566 write_handler_guard_ = true; | |
| 567 if (frame_type == SYN_STREAM) { | |
| 568 delegate_->OnRequestHeadersSent(); | |
| 569 } else { | |
| 570 delegate_->OnDataSent(); | |
| 571 } | |
| 572 CHECK(weak_this); | |
| 573 write_handler_guard_ = false; | |
| 574 } | |
| 575 | |
| 576 if (io_state_ == STATE_CLOSED) { | |
| 577 // Deletes |this|. | |
| 578 session_->CloseActiveStream(stream_id_, OK); | |
| 579 } | |
| 580 } | |
| 581 | |
| 582 int SpdyStream::OnRequestHeadersSent() { | |
| 583 CHECK_EQ(io_state_, STATE_IDLE); | |
| 584 CHECK_NE(stream_id_, 0u); | |
| 585 | |
| 586 io_state_ = STATE_OPEN; | |
| 587 return OK; | |
| 588 } | |
| 589 | |
| 590 int SpdyStream::OnDataSent(size_t frame_size) { | |
| 591 CHECK(io_state_ == STATE_OPEN || | |
| 592 io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_; | |
| 593 | |
| 594 size_t frame_payload_size = frame_size - session_->GetDataFrameMinimumSize(); | |
| 595 | |
| 596 CHECK_GE(frame_size, session_->GetDataFrameMinimumSize()); | |
| 597 CHECK_LE(frame_payload_size, session_->GetDataFrameMaximumPayload()); | |
| 598 | |
| 599 send_bytes_ += frame_payload_size; | |
| 600 | |
| 601 // If more data is available to send, dispatch it and | |
| 602 // return that the write operation is still ongoing. | |
| 603 pending_send_data_->DidConsume(frame_payload_size); | |
| 604 if (pending_send_data_->BytesRemaining() > 0) { | |
| 605 QueueNextDataFrame(); | |
| 606 return ERR_IO_PENDING; | |
| 607 } else { | |
| 608 pending_send_data_ = NULL; | |
| 609 return OK; | |
| 610 } | |
| 611 } | |
| 612 | |
| 613 SpdyMajorVersion SpdyStream::GetProtocolVersion() const { | |
| 614 return session_->GetProtocolVersion(); | |
| 615 } | |
| 616 | |
| 617 void SpdyStream::LogStreamError(int status, const std::string& description) { | |
| 618 net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ERROR, | |
| 619 base::Bind(&NetLogSpdyStreamErrorCallback, | |
| 620 stream_id_, status, &description)); | |
| 621 } | |
| 622 | |
| 623 void SpdyStream::OnClose(int status) { | |
| 624 // In most cases, the stream should already be CLOSED. The exception is when a | |
| 625 // SpdySession is shutting down while the stream is in an intermediate state. | |
| 626 io_state_ = STATE_CLOSED; | |
| 627 response_status_ = status; | |
| 628 Delegate* delegate = delegate_; | |
| 629 delegate_ = NULL; | |
| 630 if (delegate) | |
| 631 delegate->OnClose(status); | |
| 632 // Unset |stream_id_| last so that the delegate can look it up. | |
| 633 stream_id_ = 0; | |
| 634 } | |
| 635 | |
| 636 void SpdyStream::Cancel() { | |
| 637 // We may be called again from a delegate's OnClose(). | |
| 638 if (io_state_ == STATE_CLOSED) | |
| 639 return; | |
| 640 | |
| 641 if (stream_id_ != 0) { | |
| 642 session_->ResetStream(stream_id_, RST_STREAM_CANCEL, std::string()); | |
| 643 } else { | |
| 644 session_->CloseCreatedStream(GetWeakPtr(), RST_STREAM_CANCEL); | |
| 645 } | |
| 646 // |this| is invalid at this point. | |
| 647 } | |
| 648 | |
| 649 void SpdyStream::Close() { | |
| 650 // We may be called again from a delegate's OnClose(). | |
| 651 if (io_state_ == STATE_CLOSED) | |
| 652 return; | |
| 653 | |
| 654 if (stream_id_ != 0) { | |
| 655 session_->CloseActiveStream(stream_id_, OK); | |
| 656 } else { | |
| 657 session_->CloseCreatedStream(GetWeakPtr(), OK); | |
| 658 } | |
| 659 // |this| is invalid at this point. | |
| 660 } | |
| 661 | |
| 662 base::WeakPtr<SpdyStream> SpdyStream::GetWeakPtr() { | |
| 663 return weak_ptr_factory_.GetWeakPtr(); | |
| 664 } | |
| 665 | |
| 666 int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> request_headers, | |
| 667 SpdySendStatus send_status) { | |
| 668 CHECK_NE(type_, SPDY_PUSH_STREAM); | |
| 669 CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND); | |
| 670 CHECK(!request_headers_); | |
| 671 CHECK(!pending_send_data_.get()); | |
| 672 CHECK_EQ(io_state_, STATE_IDLE); | |
| 673 request_headers_ = request_headers.Pass(); | |
| 674 pending_send_status_ = send_status; | |
| 675 session_->EnqueueStreamWrite( | |
| 676 GetWeakPtr(), SYN_STREAM, | |
| 677 scoped_ptr<SpdyBufferProducer>( | |
| 678 new SynStreamBufferProducer(GetWeakPtr()))); | |
| 679 return ERR_IO_PENDING; | |
| 680 } | |
| 681 | |
| 682 void SpdyStream::SendData(IOBuffer* data, | |
| 683 int length, | |
| 684 SpdySendStatus send_status) { | |
| 685 CHECK_NE(type_, SPDY_PUSH_STREAM); | |
| 686 CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND); | |
| 687 CHECK(io_state_ == STATE_OPEN || | |
| 688 io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_; | |
| 689 CHECK(!pending_send_data_.get()); | |
| 690 pending_send_data_ = new DrainableIOBuffer(data, length); | |
| 691 pending_send_status_ = send_status; | |
| 692 QueueNextDataFrame(); | |
| 693 } | |
| 694 | |
| 695 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info, | |
| 696 bool* was_npn_negotiated, | |
| 697 NextProto* protocol_negotiated) { | |
| 698 return session_->GetSSLInfo( | |
| 699 ssl_info, was_npn_negotiated, protocol_negotiated); | |
| 700 } | |
| 701 | |
| 702 bool SpdyStream::GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) { | |
| 703 return session_->GetSSLCertRequestInfo(cert_request_info); | |
| 704 } | |
| 705 | |
| 706 void SpdyStream::PossiblyResumeIfSendStalled() { | |
| 707 if (IsLocallyClosed()) { | |
| 708 return; | |
| 709 } | |
| 710 if (send_stalled_by_flow_control_ && !session_->IsSendStalled() && | |
| 711 send_window_size_ > 0) { | |
| 712 net_log_.AddEvent( | |
| 713 NetLog::TYPE_SPDY_STREAM_FLOW_CONTROL_UNSTALLED, | |
| 714 NetLog::IntegerCallback("stream_id", stream_id_)); | |
| 715 send_stalled_by_flow_control_ = false; | |
| 716 QueueNextDataFrame(); | |
| 717 } | |
| 718 } | |
| 719 | |
| 720 bool SpdyStream::IsClosed() const { | |
| 721 return io_state_ == STATE_CLOSED; | |
| 722 } | |
| 723 | |
| 724 bool SpdyStream::IsLocallyClosed() const { | |
| 725 return io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED || | |
| 726 io_state_ == STATE_HALF_CLOSED_LOCAL || | |
| 727 io_state_ == STATE_CLOSED; | |
| 728 } | |
| 729 | |
| 730 bool SpdyStream::IsIdle() const { | |
| 731 return io_state_ == STATE_IDLE; | |
| 732 } | |
| 733 | |
| 734 bool SpdyStream::IsOpen() const { | |
| 735 return io_state_ == STATE_OPEN; | |
| 736 } | |
| 737 | |
| 738 bool SpdyStream::IsReservedRemote() const { | |
| 739 return io_state_ == STATE_RESERVED_REMOTE; | |
| 740 } | |
| 741 | |
| 742 NextProto SpdyStream::GetProtocol() const { | |
| 743 return session_->protocol(); | |
| 744 } | |
| 745 | |
| 746 bool SpdyStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const { | |
| 747 if (stream_id_ == 0) | |
| 748 return false; | |
| 749 | |
| 750 return session_->GetLoadTimingInfo(stream_id_, load_timing_info); | |
| 751 } | |
| 752 | |
| 753 GURL SpdyStream::GetUrlFromHeaders() const { | |
| 754 if (!request_headers_) | |
| 755 return GURL(); | |
| 756 | |
| 757 return GetUrlFromHeaderBlock( | |
| 758 *request_headers_, GetProtocolVersion(), type_ == SPDY_PUSH_STREAM); | |
| 759 } | |
| 760 | |
| 761 bool SpdyStream::HasUrlFromHeaders() const { | |
| 762 return !GetUrlFromHeaders().is_empty(); | |
| 763 } | |
| 764 | |
| 765 void SpdyStream::UpdateHistograms() { | |
| 766 // We need at least the receive timers to be filled in, as otherwise | |
| 767 // metrics can be bogus. | |
| 768 if (recv_first_byte_time_.is_null() || recv_last_byte_time_.is_null()) | |
| 769 return; | |
| 770 | |
| 771 base::TimeTicks effective_send_time; | |
| 772 if (type_ == SPDY_PUSH_STREAM) { | |
| 773 // Push streams shouldn't have |send_time_| filled in. | |
| 774 DCHECK(send_time_.is_null()); | |
| 775 effective_send_time = recv_first_byte_time_; | |
| 776 } else { | |
| 777 // For non-push streams, we also need |send_time_| to be filled | |
| 778 // in. | |
| 779 if (send_time_.is_null()) | |
| 780 return; | |
| 781 effective_send_time = send_time_; | |
| 782 } | |
| 783 | |
| 784 UMA_HISTOGRAM_TIMES("Net.SpdyStreamTimeToFirstByte", | |
| 785 recv_first_byte_time_ - effective_send_time); | |
| 786 UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime", | |
| 787 recv_last_byte_time_ - recv_first_byte_time_); | |
| 788 UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime", | |
| 789 recv_last_byte_time_ - effective_send_time); | |
| 790 | |
| 791 UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_); | |
| 792 UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_); | |
| 793 } | |
| 794 | |
| 795 void SpdyStream::QueueNextDataFrame() { | |
| 796 // Until the request has been completely sent, we cannot be sure | |
| 797 // that our stream_id is correct. | |
| 798 CHECK(io_state_ == STATE_OPEN || | |
| 799 io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_; | |
| 800 CHECK_GT(stream_id_, 0u); | |
| 801 CHECK(pending_send_data_.get()); | |
| 802 // Only the final fame may have a length of 0. | |
| 803 if (pending_send_status_ == NO_MORE_DATA_TO_SEND) { | |
| 804 CHECK_GE(pending_send_data_->BytesRemaining(), 0); | |
| 805 } else { | |
| 806 CHECK_GT(pending_send_data_->BytesRemaining(), 0); | |
| 807 } | |
| 808 | |
| 809 SpdyDataFlags flags = | |
| 810 (pending_send_status_ == NO_MORE_DATA_TO_SEND) ? | |
| 811 DATA_FLAG_FIN : DATA_FLAG_NONE; | |
| 812 scoped_ptr<SpdyBuffer> data_buffer( | |
| 813 session_->CreateDataBuffer(stream_id_, | |
| 814 pending_send_data_.get(), | |
| 815 pending_send_data_->BytesRemaining(), | |
| 816 flags)); | |
| 817 // We'll get called again by PossiblyResumeIfSendStalled(). | |
| 818 if (!data_buffer) | |
| 819 return; | |
| 820 | |
| 821 if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) { | |
| 822 DCHECK_GE(data_buffer->GetRemainingSize(), | |
| 823 session_->GetDataFrameMinimumSize()); | |
| 824 size_t payload_size = | |
| 825 data_buffer->GetRemainingSize() - session_->GetDataFrameMinimumSize(); | |
| 826 DCHECK_LE(payload_size, session_->GetDataFrameMaximumPayload()); | |
| 827 | |
| 828 // Send window size is based on payload size, so nothing to do if this is | |
| 829 // just a FIN with no payload. | |
| 830 if (payload_size != 0) { | |
| 831 DecreaseSendWindowSize(static_cast<int32>(payload_size)); | |
| 832 // This currently isn't strictly needed, since write frames are | |
| 833 // discarded only if the stream is about to be closed. But have it | |
| 834 // here anyway just in case this changes. | |
| 835 data_buffer->AddConsumeCallback( | |
| 836 base::Bind(&SpdyStream::OnWriteBufferConsumed, | |
| 837 GetWeakPtr(), payload_size)); | |
| 838 } | |
| 839 } | |
| 840 | |
| 841 session_->EnqueueStreamWrite( | |
| 842 GetWeakPtr(), DATA, | |
| 843 scoped_ptr<SpdyBufferProducer>( | |
| 844 new SimpleBufferProducer(data_buffer.Pass()))); | |
| 845 } | |
| 846 | |
| 847 int SpdyStream::MergeWithResponseHeaders( | |
| 848 const SpdyHeaderBlock& new_response_headers) { | |
| 849 if (new_response_headers.find("transfer-encoding") != | |
| 850 new_response_headers.end()) { | |
| 851 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 852 "Received transfer-encoding header"); | |
| 853 return ERR_SPDY_PROTOCOL_ERROR; | |
| 854 } | |
| 855 | |
| 856 for (SpdyHeaderBlock::const_iterator it = new_response_headers.begin(); | |
| 857 it != new_response_headers.end(); ++it) { | |
| 858 // Disallow uppercase headers. | |
| 859 if (ContainsUppercaseAscii(it->first)) { | |
| 860 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 861 "Upper case characters in header: " + it->first); | |
| 862 return ERR_SPDY_PROTOCOL_ERROR; | |
| 863 } | |
| 864 | |
| 865 SpdyHeaderBlock::iterator it2 = response_headers_.lower_bound(it->first); | |
| 866 // Disallow duplicate headers. This is just to be conservative. | |
| 867 if (it2 != response_headers_.end() && it2->first == it->first) { | |
| 868 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 869 "Duplicate header: " + it->first); | |
| 870 return ERR_SPDY_PROTOCOL_ERROR; | |
| 871 } | |
| 872 | |
| 873 response_headers_.insert(it2, *it); | |
| 874 } | |
| 875 | |
| 876 // If delegate_ is not yet attached, we'll call | |
| 877 // OnResponseHeadersUpdated() after the delegate gets attached to | |
| 878 // the stream. | |
| 879 if (delegate_) { | |
| 880 // The call to OnResponseHeadersUpdated() below may delete |this|, | |
| 881 // so use |weak_this| to detect that. | |
| 882 base::WeakPtr<SpdyStream> weak_this = GetWeakPtr(); | |
| 883 | |
| 884 SpdyResponseHeadersStatus status = | |
| 885 delegate_->OnResponseHeadersUpdated(response_headers_); | |
| 886 if (status == RESPONSE_HEADERS_ARE_INCOMPLETE) { | |
| 887 // Since RESPONSE_HEADERS_ARE_INCOMPLETE was returned, we must not | |
| 888 // have been closed. | |
| 889 CHECK(weak_this); | |
| 890 // Incomplete headers are OK only for push streams. | |
| 891 if (type_ != SPDY_PUSH_STREAM) { | |
| 892 session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, | |
| 893 "Incomplete headers"); | |
| 894 return ERR_INCOMPLETE_SPDY_HEADERS; | |
| 895 } | |
| 896 } else if (weak_this) { | |
| 897 response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE; | |
| 898 } | |
| 899 } | |
| 900 | |
| 901 return OK; | |
| 902 } | |
| 903 | |
| 904 #define STATE_CASE(s) \ | |
| 905 case s: \ | |
| 906 description = base::StringPrintf("%s (0x%08X)", #s, s); \ | |
| 907 break | |
| 908 | |
| 909 std::string SpdyStream::DescribeState(State state) { | |
| 910 std::string description; | |
| 911 switch (state) { | |
| 912 STATE_CASE(STATE_IDLE); | |
| 913 STATE_CASE(STATE_OPEN); | |
| 914 STATE_CASE(STATE_HALF_CLOSED_LOCAL_UNCLAIMED); | |
| 915 STATE_CASE(STATE_HALF_CLOSED_LOCAL); | |
| 916 STATE_CASE(STATE_CLOSED); | |
| 917 default: | |
| 918 description = base::StringPrintf("Unknown state 0x%08X (%u)", state, | |
| 919 state); | |
| 920 break; | |
| 921 } | |
| 922 return description; | |
| 923 } | |
| 924 | |
| 925 #undef STATE_CASE | |
| 926 | |
| 927 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master