Disallow multiple HEADERS frames on pushed streams.

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 521 matching lines @@
 void SpdyStreamRequest::Reset() {
   type_ = SPDY_BIDIRECTIONAL_STREAM;
   session_.reset();
   stream_.reset();
   url_ = GURL();
   priority_ = MINIMUM_PRIORITY;
   net_log_ = NetLogWithSource();
   callback_.Reset();
 }
 
-SpdySession::ActiveStreamInfo::ActiveStreamInfo()
-    : stream(NULL), waiting_for_reply_headers_frame(false) {}
-
-SpdySession::ActiveStreamInfo::ActiveStreamInfo(SpdyStream* stream)
-    : stream(stream),
-      waiting_for_reply_headers_frame(stream->type() != SPDY_PUSH_STREAM) {}
-
-SpdySession::ActiveStreamInfo::~ActiveStreamInfo() {}
-
 SpdySession::UnclaimedPushedStreamContainer::UnclaimedPushedStreamContainer(
     SpdySession* spdy_session)
     : spdy_session_(spdy_session) {}
 SpdySession::UnclaimedPushedStreamContainer::~UnclaimedPushedStreamContainer() {
 }
 
 size_t SpdySession::UnclaimedPushedStreamContainer::erase(const GURL& url) {
   const_iterator it = find(url);
   if (it != end()) {
     streams_.erase(it);
@@ skipping 427 matching lines @@
   EnqueueWrite(stream->priority(), frame_type, std::move(producer), stream);
 }
 
 std::unique_ptr<SpdySerializedFrame> SpdySession::CreateHeaders(
     SpdyStreamId stream_id,
     RequestPriority priority,
     SpdyControlFlags flags,
     SpdyHeaderBlock block) {
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   CHECK(it != active_streams_.end());
-  CHECK_EQ(it->second.stream->stream_id(), stream_id);
+  CHECK_EQ(it->second->stream_id(), stream_id);
 
   SendPrefacePingIfNoneInFlight();
 
   DCHECK(buffered_spdy_framer_.get());
   SpdyPriority spdy_priority = ConvertRequestPriorityToSpdyPriority(priority);
 
   std::unique_ptr<SpdySerializedFrame> syn_frame;
   bool has_priority = true;
   int weight = Spdy3PriorityToHttp2Weight(spdy_priority);
   SpdyStreamId dependent_stream_id = 0;
@@ skipping 28 matching lines @@
     SpdyStreamId stream_id,
     IOBuffer* data,
     int len,
     SpdyDataFlags flags) {
   if (availability_state_ == STATE_DRAINING) {
     return std::unique_ptr<SpdyBuffer>();
   }
 
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   CHECK(it != active_streams_.end());
-  SpdyStream* stream = it->second.stream;
+  SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   if (len < 0) {
     NOTREACHED();
     return std::unique_ptr<SpdyBuffer>();
   }
 
   int effective_len = std::min(len, kMaxSpdyFrameChunkSize);
 
   bool send_stalled_by_stream = (stream->send_window_size() <= 0);
@@ skipping 134 matching lines @@
   // Just report that we're idle since the session could be doing
   // many things concurrently.
   return LOAD_STATE_IDLE;
 }
 
 void SpdySession::CloseActiveStreamIterator(ActiveStreamMap::iterator it,
                                             int status) {
   // TODO(mbelshe): We should send a RST_STREAM control frame here
   //                so that the server can cancel a large send.
 
-  std::unique_ptr<SpdyStream> owned_stream(it->second.stream);
+  std::unique_ptr<SpdyStream> owned_stream(it->second);
   active_streams_.erase(it);
   priority_dependency_state_.OnStreamDestruction(owned_stream->stream_id());
 
   // TODO(akalin): When SpdyStream was ref-counted (and
   // |unclaimed_pushed_streams_| held scoped_refptr<SpdyStream>), this
   // was only done when status was not OK. This meant that pushed
   // streams can still be claimed after they're closed. This is
   // probably something that we still want to support, although server
   // push is hardly used. Write tests for this and fix this. (See
   // http://crbug.com/261712 .)
@@ skipping 21 matching lines @@
   created_streams_.erase(it);
   DeleteStream(std::move(owned_stream), status);
 }
 
 void SpdySession::ResetStreamIterator(ActiveStreamMap::iterator it,
                                       SpdyRstStreamStatus status,
                                       const std::string& description) {
   // Send the RST_STREAM frame first as CloseActiveStreamIterator()
   // may close us.
   SpdyStreamId stream_id = it->first;
-  RequestPriority priority = it->second.stream->priority();
+  RequestPriority priority = it->second->priority();
   EnqueueResetStreamFrame(stream_id, priority, status, description);
 
   // Removes any pending writes for the stream except for possibly an
   // in-flight one.
   CloseActiveStreamIterator(it, ERR_SPDY_PROTOCOL_ERROR);
 }
 
 void SpdySession::EnqueueResetStreamFrame(SpdyStreamId stream_id,
                                           RequestPriority priority,
                                           SpdyRstStreamStatus status,
@@ skipping 428 matching lines @@
   stream->LogStreamError(status, description);
   // We don't increment the streams abandoned counter here. If the
   // stream isn't active (i.e., it hasn't written anything to the wire
   // yet) then it's as if it never existed. If it is active, then
   // LogAbandonedActiveStream() will increment the counters.
 }
 
 void SpdySession::LogAbandonedActiveStream(ActiveStreamMap::const_iterator it,
                                            Error status) {
   DCHECK_GT(it->first, 0u);
-  LogAbandonedStream(it->second.stream, status);
+  LogAbandonedStream(it->second, status);
   ++streams_abandoned_count_;
 }
 
 SpdyStreamId SpdySession::GetNewStreamId() {
   CHECK_LE(stream_hi_water_mark_, kLastStreamId);
   SpdyStreamId id = stream_hi_water_mark_;
   stream_hi_water_mark_ += 2;
   return id;
 }
 
@@ skipping 137 matching lines @@
   stream->set_stream_id(GetNewStreamId());
   std::unique_ptr<SpdyStream> owned_stream(stream);
   created_streams_.erase(stream);
   return owned_stream;
 }
 
 void SpdySession::InsertActivatedStream(std::unique_ptr<SpdyStream> stream) {
   SpdyStreamId stream_id = stream->stream_id();
   CHECK_NE(stream_id, 0u);
   std::pair<ActiveStreamMap::iterator, bool> result =
-      active_streams_.insert(
-          std::make_pair(stream_id, ActiveStreamInfo(stream.get())));
+      active_streams_.insert(std::make_pair(stream_id, stream.get()));
   CHECK(result.second);
   ignore_result(stream.release());
 }
 
 void SpdySession::DeleteStream(std::unique_ptr<SpdyStream> stream, int status) {
   if (in_flight_write_stream_.get() == stream.get()) {
     // If we're deleting the stream for the in-flight write, we still
     // need to let the write complete, so we clear
     // |in_flight_write_stream_| and let the write finish on its own
     // without notifying |in_flight_write_stream_|.
@@ skipping 26 matching lines @@
   unclaimed_pushed_streams_.erase(unclaimed_it);
 
   ActiveStreamMap::iterator active_it = active_streams_.find(stream_id);
   if (active_it == active_streams_.end()) {
     NOTREACHED();
     return base::WeakPtr<SpdyStream>();
   }
 
   net_log_.AddEvent(NetLogEventType::HTTP2_STREAM_ADOPTED_PUSH_STREAM,
                     base::Bind(&NetLogSpdyAdoptedPushStreamCallback,
-                               active_it->second.stream->stream_id(), &url));
-  return active_it->second.stream->GetWeakPtr();
+                               active_it->second->stream_id(), &url));
+  return active_it->second->GetWeakPtr();
 }
 
 url::SchemeHostPort SpdySession::GetServer() {
   return url::SchemeHostPort(is_secure_ ? "https" : "http",
                              host_port_pair().host(), host_port_pair().port());
 }
 
 bool SpdySession::GetSSLInfo(SSLInfo* ssl_info) const {
   return connection_->socket()->GetSSLInfo(ssl_info);
 }
@@ skipping 49 matching lines @@
                                     size_t length,
                                     bool fin) {
   CHECK(in_io_loop_);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
 
   // By the time data comes in, the stream may already be inactive.
   if (it == active_streams_.end())
     return;
 
-  SpdyStream* stream = it->second.stream;
+  SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   DCHECK(buffered_spdy_framer_);
   size_t header_len = buffered_spdy_framer_->GetDataFrameMinimumSize();
   stream->AddRawReceivedBytes(header_len);
 }
 
 void SpdySession::OnStreamFrameData(SpdyStreamId stream_id,
                                     const char* data,
                                     size_t len) {
@@ skipping 22 matching lines @@
   } else {
     DCHECK_EQ(len, 0u);
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
 
   // By the time data comes in, the stream may already be inactive.
   if (it == active_streams_.end())
     return;
 
-  SpdyStream* stream = it->second.stream;
+  SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   stream->AddRawReceivedBytes(len);
-
-  if (it->second.waiting_for_reply_headers_frame) {
-    const std::string& error = "DATA received before HEADERS.";
-    stream->LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-    ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, error);
-    return;
-  }
-
   stream->OnDataReceived(std::move(buffer));
 }
 
 void SpdySession::OnStreamEnd(SpdyStreamId stream_id) {
   CHECK(in_io_loop_);
   if (net_log().IsCapturing()) {
     net_log().AddEvent(NetLogEventType::HTTP2_SESSION_RECV_DATA,
                        base::Bind(&NetLogSpdyDataCallback, stream_id, 0, true));
   }
 
   // Build the buffer as early as possible so that we go through the
   // session flow control checks and update
   // |unacked_recv_window_bytes_| properly even when the stream is
   // inactive (since the other side has still reduced its session send
   // window).
   std::unique_ptr<SpdyBuffer> buffer;
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
 
   // By the time data comes in, the stream may already be inactive.
   if (it == active_streams_.end())
     return;
 
-  SpdyStream* stream = it->second.stream;
+  SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
-  if (it->second.waiting_for_reply_headers_frame) {
-    const std::string& error = "DATA received before HEADERS.";
-    stream->LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-    ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, error);
-    return;
-  }
-
   stream->OnDataReceived(std::move(buffer));
 }
 
 void SpdySession::OnStreamPadding(SpdyStreamId stream_id, size_t len) {
   CHECK(in_io_loop_);
 
   // Decrease window size because padding bytes are received.
   // Increase window size because padding bytes are consumed (by discarding).
   // Net result: |session_unacked_recv_window_bytes_| increases by |len|,
   // |session_recv_window_size_| does not change.
   DecreaseRecvWindowSize(static_cast<int32_t>(len));
   IncreaseRecvWindowSize(static_cast<int32_t>(len));
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end())
     return;
-  it->second.stream->OnPaddingConsumed(len);
+  it->second->OnPaddingConsumed(len);
 }
 
 void SpdySession::OnSettings() {
   CHECK(in_io_loop_);
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(
         NetLogEventType::HTTP2_SESSION_RECV_SETTINGS,
         base::Bind(&NetLogSpdySettingsCallback, host_port_pair()));
   }
@@ skipping 38 matching lines @@
   }
 }
 
 void SpdySession::OnReceiveCompressedFrame(
     SpdyStreamId stream_id,
     SpdyFrameType type,
     size_t frame_len) {
   last_compressed_frame_len_ = frame_len;
 }
 
-int SpdySession::OnInitialResponseHeadersReceived(
-    const SpdyHeaderBlock& response_headers,
-    base::Time response_time,
-    base::TimeTicks recv_first_byte_time,
-    SpdyStream* stream) {
-  CHECK(in_io_loop_);
-  SpdyStreamId stream_id = stream->stream_id();
-
-  if (stream->type() == SPDY_PUSH_STREAM) {
-    DCHECK(stream->IsReservedRemote());
-    if (max_concurrent_pushed_streams_ &&
-        num_active_pushed_streams_ >= max_concurrent_pushed_streams_) {
-      ResetStream(stream_id,
-                  RST_STREAM_REFUSED_STREAM,
-                  "Stream concurrency limit reached.");
-      return STATUS_CODE_REFUSED_STREAM;
-    }
-  }
-
-  if (stream->type() == SPDY_PUSH_STREAM) {
-    // Will be balanced in DeleteStream.
-    num_active_pushed_streams_++;
-  }
-
-  // May invalidate |stream|.
-  int rv = stream->OnInitialResponseHeadersReceived(
-      response_headers, response_time, recv_first_byte_time);
-  if (rv < 0) {
-    DCHECK_NE(rv, ERR_IO_PENDING);
-    DCHECK(active_streams_.find(stream_id) == active_streams_.end());
-  }
-
-  return rv;
-}
-
 void SpdySession::DeleteExpiredPushedStreams() {
   if (unclaimed_pushed_streams_.empty())
     return;
 
   // Check that adequate time has elapsed since the last sweep.
   if (time_func_() < next_unclaimed_push_stream_sweep_time_)
     return;
 
   // Gather old streams to delete.
   base::TimeTicks minimum_freshness = time_func_() -
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
   std::vector<SpdyStreamId> streams_to_close;
   for (UnclaimedPushedStreamContainer::const_iterator it =
            unclaimed_pushed_streams_.begin();
        it != unclaimed_pushed_streams_.end(); ++it) {
     if (minimum_freshness > it->second.creation_time)
       streams_to_close.push_back(it->second.stream_id);
   }
 
   for (std::vector<SpdyStreamId>::const_iterator to_close_it =
            streams_to_close.begin();
        to_close_it != streams_to_close.end(); ++to_close_it) {
     ActiveStreamMap::iterator active_it = active_streams_.find(*to_close_it);
     if (active_it == active_streams_.end())
       continue;
-    bytes_pushed_and_unclaimed_count_ += active_it->second.stream->recv_bytes();
+    bytes_pushed_and_unclaimed_count_ += active_it->second->recv_bytes();
 
     LogAbandonedActiveStream(active_it, ERR_INVALID_SPDY_STREAM);
     // CloseActiveStreamIterator() will remove the stream from
     // |unclaimed_pushed_streams_|.
     ResetStreamIterator(
         active_it, RST_STREAM_REFUSED_STREAM, "Stream not claimed.");
   }
 
   next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
@@ skipping 14 matching lines @@
                                   fin, stream_id));
   }
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received HEADERS for invalid stream " << stream_id;
     return;
   }
 
-  SpdyStream* stream = it->second.stream;
+  SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   stream->AddRawReceivedBytes(last_compressed_frame_len_);
   last_compressed_frame_len_ = 0;
 
+  if (it->second->IsReservedRemote()) {
+    DCHECK_EQ(SPDY_PUSH_STREAM, stream->type());
+    if (max_concurrent_pushed_streams_ &&
+        num_active_pushed_streams_ >= max_concurrent_pushed_streams_) {
+      ResetStream(stream_id, RST_STREAM_REFUSED_STREAM,
+                  "Stream concurrency limit reached.");
+      return;
+    }
+
+    // Will be balanced in DeleteStream.
+    num_active_pushed_streams_++;
+  }
+
   base::Time response_time = base::Time::Now();
   base::TimeTicks recv_first_byte_time = time_func_();
-
-  if (it->second.waiting_for_reply_headers_frame) {
-    it->second.waiting_for_reply_headers_frame = false;
-    ignore_result(OnInitialResponseHeadersReceived(
-        headers, response_time, recv_first_byte_time, stream));
-  } else if (it->second.stream->IsReservedRemote()) {
-    ignore_result(OnInitialResponseHeadersReceived(
-        headers, response_time, recv_first_byte_time, stream));
-  } else {
-    int rv = stream->OnAdditionalResponseHeadersReceived(headers);
-    if (rv < 0) {
-      DCHECK_NE(rv, ERR_IO_PENDING);
-      DCHECK(active_streams_.find(stream_id) == active_streams_.end());
-    }
-  }
+  // May invalidate |stream|.
+  stream->OnHeadersReceived(headers, response_time, recv_first_byte_time);
 }
 
 void SpdySession::OnAltSvc(
     SpdyStreamId stream_id,
     base::StringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   if (!is_secure_)
     return;
 
   url::SchemeHostPort scheme_host_port;
@@ skipping 10 matching lines @@
                  gurl.host())) {
       return;
     }
     scheme_host_port = url::SchemeHostPort(gurl);
   } else {
     if (!origin.empty())
       return;
     const ActiveStreamMap::iterator it = active_streams_.find(stream_id);
     if (it == active_streams_.end())
       return;
-    const GURL& gurl(it->second.stream->url());
+    const GURL& gurl(it->second->url());
     if (!gurl.SchemeIs("https"))
       return;
     scheme_host_port = url::SchemeHostPort(gurl);
   }
 
   AlternativeServiceInfoVector alternative_service_info_vector;
   alternative_service_info_vector.reserve(altsvc_vector.size());
   const base::Time now(base::Time::Now());
   for (const SpdyAltSvcWireFormat::AlternativeService& altsvc : altsvc_vector) {
     const NextProto protocol = NextProtoFromString(altsvc.protocol_id);
@@ skipping 31 matching lines @@
       NetLogEventType::HTTP2_SESSION_RST_STREAM,
       base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received RST for invalid stream" << stream_id;
     return;
   }
 
-  CHECK_EQ(it->second.stream->stream_id(), stream_id);
+  CHECK_EQ(it->second->stream_id(), stream_id);
 
   if (status == RST_STREAM_NO_ERROR) {
     CloseActiveStreamIterator(it, ERR_SPDY_RST_STREAM_NO_ERROR_RECEIVED);
   } else if (status == RST_STREAM_REFUSED_STREAM) {
     CloseActiveStreamIterator(it, ERR_SPDY_SERVER_REFUSED_STREAM);
   } else if (status == RST_STREAM_HTTP_1_1_REQUIRED) {
     // TODO(bnc): Record histogram with number of open streams capped at 50.
-    it->second.stream->LogStreamError(
+    it->second->LogStreamError(
         ERR_HTTP_1_1_REQUIRED,
         base::StringPrintf(
             "SPDY session closed because of stream with status: %d", status));
     DoDrainSession(ERR_HTTP_1_1_REQUIRED, "HTTP_1_1_REQUIRED for stream.");
   } else {
     RecordProtocolErrorHistogram(
         PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM);
-    it->second.stream->LogStreamError(
+    it->second->LogStreamError(
         ERR_SPDY_PROTOCOL_ERROR,
         base::StringPrintf("SPDY stream closed with status: %d", status));
     // TODO(mbelshe): Map from Spdy-protocol errors to something sensical.
     //                For now, it doesn't matter much - it is a protocol error.
     CloseActiveStreamIterator(it, ERR_SPDY_PROTOCOL_ERROR);
   }
 }
 
 void SpdySession::OnGoAway(SpdyStreamId last_accepted_stream_id,
                            SpdyGoAwayStatus status,
@@ skipping 73 matching lines @@
   } else {
     // WINDOW_UPDATE for a stream.
     ActiveStreamMap::iterator it = active_streams_.find(stream_id);
 
     if (it == active_streams_.end()) {
       // NOTE:  it may just be that the stream was cancelled.
       LOG(WARNING) << "Received WINDOW_UPDATE for invalid stream " << stream_id;
       return;
     }
 
-    SpdyStream* stream = it->second.stream;
+    SpdyStream* stream = it->second;
     CHECK_EQ(stream->stream_id(), stream_id);
 
     if (delta_window_size < 1) {
       ResetStreamIterator(it, RST_STREAM_FLOW_CONTROL_ERROR,
                           base::StringPrintf(
                               "Received WINDOW_UPDATE with an invalid "
                               "delta_window_size %d",
                               delta_window_size));
       return;
     }
 
-    CHECK_EQ(it->second.stream->stream_id(), stream_id);
-    it->second.stream->IncreaseSendWindowSize(delta_window_size);
+    CHECK_EQ(it->second->stream_id(), stream_id);
+    it->second->IncreaseSendWindowSize(delta_window_size);
   }
 }
 
-bool SpdySession::TryCreatePushStream(SpdyStreamId stream_id,
+void SpdySession::TryCreatePushStream(SpdyStreamId stream_id,
                                       SpdyStreamId associated_stream_id,
                                       SpdyPriority priority,
                                       SpdyHeaderBlock headers) {
   // Server-initiated streams should have even sequence numbers.
   if ((stream_id & 0x1) != 0) {
     LOG(WARNING) << "Received invalid push stream id " << stream_id;
     CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Odd push stream id.");
-    return false;
+    return;
   }
 
   // Server-initiated streams must be associated with client-initiated streams.
   if ((associated_stream_id & 0x1) != 1) {
     LOG(WARNING) << "Received push stream id " << stream_id
                  << " with invalid associated stream id";
     CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Push on even stream id.");
-    return false;
+    return;
   }
 
   if (stream_id <= last_accepted_push_stream_id_) {
     LOG(WARNING) << "Received push stream id " << stream_id
                  << " lesser or equal to the last accepted before";
     CloseSessionOnError(
         ERR_SPDY_PROTOCOL_ERROR,
         "New push stream id must be greater than the last accepted.");
-    return false;
+    return;
   }
 
   if (IsStreamActive(stream_id)) {
     // We should not get here, we'll start going away earlier on
     // |last_seen_push_stream_id_| check.
     LOG(WARNING) << "Received push for active stream " << stream_id;
-    return false;
+    return;
   }
 
   last_accepted_push_stream_id_ = stream_id;
 
   RequestPriority request_priority =
       ConvertSpdyPriorityToRequestPriority(priority);
 
   if (availability_state_ == STATE_GOING_AWAY) {
     // TODO(akalin): This behavior isn't in the SPDY spec, although it
     // probably should be.
     EnqueueResetStreamFrame(stream_id,
                             request_priority,
                             RST_STREAM_REFUSED_STREAM,
                             "push stream request received when going away");
-    return false;
+    return;
   }
 
   if (associated_stream_id == 0) {
     // In HTTP/2 0 stream id in PUSH_PROMISE frame leads to framer error and
     // session going away. We should never get here.
     std::string description = base::StringPrintf(
         "Received invalid associated stream id %d for pushed stream %d",
         associated_stream_id,
         stream_id);
     EnqueueResetStreamFrame(
         stream_id, request_priority, RST_STREAM_REFUSED_STREAM, description);
-    return false;
+    return;
   }
 
   streams_pushed_count_++;
 
   // TODO(mbelshe): DCHECK that this is a GET method?
 
   // Verify that the response had a URL for us.
   GURL gurl = GetUrlFromHeaderBlock(headers);
   if (!gurl.is_valid()) {
     EnqueueResetStreamFrame(stream_id,
                             request_priority,
                             RST_STREAM_PROTOCOL_ERROR,
                             "Pushed stream url was invalid: " + gurl.spec());
-    return false;
+    return;
   }
 
   // Verify we have a valid stream association.
   ActiveStreamMap::iterator associated_it =
       active_streams_.find(associated_stream_id);
   if (associated_it == active_streams_.end()) {
     EnqueueResetStreamFrame(
         stream_id,
         request_priority,
         RST_STREAM_INVALID_STREAM,
         base::StringPrintf("Received push for inactive associated stream %d",
                            associated_stream_id));
-    return false;
+    return;
   }
 
   DCHECK(gurl.is_valid());
 
   // Check that the pushed stream advertises the same origin as its associated
   // stream. Bypass this check if and only if this session is with a SPDY proxy
   // that is trusted explicitly as determined by the |proxy_delegate_| or if the
   // proxy is pushing same-origin resources.
   if (!HostPortPair::FromURL(gurl).Equals(host_port_pair())) {
     if (proxy_delegate_ &&
         proxy_delegate_->IsTrustedSpdyProxy(
             ProxyServer(ProxyServer::SCHEME_HTTPS, host_port_pair()))) {
       // Disallow pushing of HTTPS content.
       if (gurl.SchemeIs("https")) {
         EnqueueResetStreamFrame(
             stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
             base::StringPrintf("Rejected push of cross origin HTTPS content %d "
                                "from trusted proxy",
                                associated_stream_id));
-        return false;
+        return;
       }
     } else {
-      GURL associated_url(associated_it->second.stream->GetUrlFromHeaders());
+      GURL associated_url(associated_it->second->GetUrlFromHeaders());
       if (associated_url.SchemeIs("https")) {
         SSLInfo ssl_info;
         CHECK(GetSSLInfo(&ssl_info));
         if (!gurl.SchemeIs("https") ||
             !CanPool(transport_security_state_, ssl_info, associated_url.host(),
                      gurl.host())) {
           EnqueueResetStreamFrame(
               stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
               base::StringPrintf("Rejected push stream %d on secure connection",
                                  associated_stream_id));
-          return false;
+          return;
         }
       } else {
         // TODO(bnc): Change SpdyNetworkTransactionTests to use secure sockets.
         if (associated_url.GetOrigin() != gurl.GetOrigin()) {
           EnqueueResetStreamFrame(
               stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
               base::StringPrintf(
                   "Rejected cross origin push stream %d on insecure connection",
                   associated_stream_id));
-          return false;
+          return;
         }
       }
     }
   }
 
   // There should not be an existing pushed stream with the same path.
   UnclaimedPushedStreamContainer::const_iterator pushed_it =
       unclaimed_pushed_streams_.lower_bound(gurl);
   if (pushed_it != unclaimed_pushed_streams_.end() &&
       pushed_it->first == gurl) {
     EnqueueResetStreamFrame(
         stream_id,
         request_priority,
         RST_STREAM_PROTOCOL_ERROR,
         "Received duplicate pushed stream with url: " + gurl.spec());
-    return false;
+    return;
   }
 
   std::unique_ptr<SpdyStream> stream(
       new SpdyStream(SPDY_PUSH_STREAM, GetWeakPtr(), gurl, request_priority,
                      stream_initial_send_window_size_,
                      stream_max_recv_window_size_, net_log_));
   stream->set_stream_id(stream_id);
 
   // In HTTP2 PUSH_PROMISE arrives on associated stream.
   if (associated_it != active_streams_.end()) {
-    associated_it->second.stream->AddRawReceivedBytes(
-        last_compressed_frame_len_);
+    associated_it->second->AddRawReceivedBytes(last_compressed_frame_len_);
   } else {
     stream->AddRawReceivedBytes(last_compressed_frame_len_);
   }
 
   last_compressed_frame_len_ = 0;
 
   UnclaimedPushedStreamContainer::const_iterator inserted_pushed_it =
       unclaimed_pushed_streams_.insert(pushed_it, gurl, stream_id,
                                        time_func_());
   DCHECK(inserted_pushed_it != pushed_it);
   DeleteExpiredPushedStreams();
 
   InsertActivatedStream(std::move(stream));
 
   ActiveStreamMap::iterator active_it = active_streams_.find(stream_id);
   if (active_it == active_streams_.end()) {
     NOTREACHED();
-    return false;
+    return;
   }
 
   // Notify the push_delegate that a push promise has been received.
   if (push_delegate_) {
     push_delegate_->OnPush(base::MakeUnique<SpdyServerPushHelper>(
         weak_factory_.GetWeakPtr(), gurl));
   }
 
-  active_it->second.stream->OnPushPromiseHeadersReceived(std::move(headers));
-  DCHECK(active_it->second.stream->IsReservedRemote());
+  active_it->second->OnPushPromiseHeadersReceived(std::move(headers));
+  DCHECK(active_it->second->IsReservedRemote());
   num_pushed_streams_++;
-  return true;
+  return;
 }
 
 void SpdySession::OnPushPromise(SpdyStreamId stream_id,
                                 SpdyStreamId promised_stream_id,
                                 SpdyHeaderBlock headers) {
   CHECK(in_io_loop_);
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(NetLogEventType::HTTP2_SESSION_RECV_PUSH_PROMISE,
                       base::Bind(&NetLogSpdyPushPromiseReceivedCallback,
                                  &headers, stream_id, promised_stream_id));
   }
 
-  // Any priority will do.
-  // TODO(baranovich): pass parent stream id priority?
-  if (!TryCreatePushStream(promised_stream_id, stream_id, 0,
-                           std::move(headers)))
-    return;
+  // Any priority will do.  TODO(baranovich): Pass parent stream id priority?
+  TryCreatePushStream(promised_stream_id, stream_id, 0, std::move(headers));
 }
 
 void SpdySession::SendStreamWindowUpdate(SpdyStreamId stream_id,
                                          uint32_t delta_window_size) {
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   CHECK(it != active_streams_.end());
-  CHECK_EQ(it->second.stream->stream_id(), stream_id);
-  SendWindowUpdateFrame(
-      stream_id, delta_window_size, it->second.stream->priority());
+  CHECK_EQ(it->second->stream_id(), stream_id);
+  SendWindowUpdateFrame(stream_id, delta_window_size, it->second->priority());
 }
 
 void SpdySession::SendInitialData() {
   DCHECK(enable_sending_initial_data_);
 
   std::unique_ptr<SpdySerializedFrame> connection_header_prefix_frame(
       new SpdySerializedFrame(const_cast<char*>(kHttp2ConnectionHeaderPrefix),
                               kHttp2ConnectionHeaderPrefixSize,
                               false /* take_ownership */));
   // Count the prefix as part of the subsequent SETTINGS frame.
@@ skipping 61 matching lines @@
           NetLogEventType::HTTP2_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE,
           NetLog::IntCallback("delta_window_size", delta_window_size));
       break;
     }
   }
 }
 
 void SpdySession::UpdateStreamsSendWindowSize(int32_t delta_window_size) {
   for (ActiveStreamMap::iterator it = active_streams_.begin();
        it != active_streams_.end(); ++it) {
-    it->second.stream->AdjustSendWindowSize(delta_window_size);
+    it->second->AdjustSendWindowSize(delta_window_size);
   }
 
   for (CreatedStreamSet::const_iterator it = created_streams_.begin();
        it != created_streams_.end(); it++) {
     (*it)->AdjustSendWindowSize(delta_window_size);
   }
 }
 
 void SpdySession::SendPrefacePingIfNoneInFlight() {
   if (pings_in_flight_ || !enable_ping_based_connection_checking_)
     return;
 
   base::TimeTicks now = time_func_();
   // If there is no activity in the session, then send a preface-PING.
   if ((now - last_activity_time_) > connection_at_risk_of_loss_time_)
     SendPrefacePing();
 }
 
 void SpdySession::SendPrefacePing() {
   WritePingFrame(next_ping_id_, false);
 }
 
 void SpdySession::SendWindowUpdateFrame(SpdyStreamId stream_id,
                                         uint32_t delta_window_size,
                                         RequestPriority priority) {
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   if (it != active_streams_.end()) {
-    CHECK_EQ(it->second.stream->stream_id(), stream_id);
+    CHECK_EQ(it->second->stream_id(), stream_id);
   } else {
     CHECK_EQ(stream_id, kSessionFlowControlStreamId);
   }
 
   net_log_.AddEvent(NetLogEventType::HTTP2_SESSION_SENT_WINDOW_UPDATE_FRAME,
                     base::Bind(&NetLogSpdyWindowUpdateFrameCallback, stream_id,
                                delta_window_size));
 
   DCHECK(buffered_spdy_framer_.get());
   std::unique_ptr<SpdySerializedFrame> window_update_frame(
@@ skipping 255 matching lines @@
 #endif
 
     SpdyStreamId stream_id = PopStreamToPossiblyResume();
     if (stream_id == 0)
       break;
     ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
     // The stream may actually still be send-stalled after this (due
     // to its own send window) but that's okay -- it'll then be
     // resumed once its send window increases.
     if (it != active_streams_.end())
-      it->second.stream->PossiblyResumeIfSendStalled();
+      it->second->PossiblyResumeIfSendStalled();
 
     // The size should decrease unless we got send-stalled again.
     if (!IsSendStalled())
       DCHECK_LT(GetTotalSize(stream_send_unstall_queue_), old_size);
   }
 }
 
 SpdyStreamId SpdySession::PopStreamToPossiblyResume() {
   for (int i = MAXIMUM_PRIORITY; i >= MINIMUM_PRIORITY; --i) {
     std::deque<SpdyStreamId>* queue = &stream_send_unstall_queue_[i];
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net