SPDY4: Turn SYN_STREAM and SYN_REPLY into HEADERS.

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 <map>
 
 #include "base/basictypes.h"
@@ skipping 1998 matching lines @@
 
   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,
                             "OnSyn received when going away");
     return;
   }
 
-  if (associated_stream_id == 0) {
+  // TODO(jgraettinger): SpdyFramer simulates OnSynStream() from HEADERS
+  // frames, which don't convey associated stream ID. Disable this check
+  // for now, and re-enable when PUSH_PROMISE is implemented properly.
+  if (associated_stream_id == 0 && GetProtocolVersion() < SPDY4) {
     std::string description = base::StringPrintf(
         "Received invalid OnSyn associated stream id %d for stream %d",
         associated_stream_id, stream_id);
     EnqueueResetStreamFrame(stream_id, request_priority,
                             RST_STREAM_REFUSED_STREAM, description);
     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, GetProtocolVersion(), true);
   if (!gurl.is_valid()) {
     EnqueueResetStreamFrame(
         stream_id, request_priority, RST_STREAM_PROTOCOL_ERROR,
         "Pushed stream url was invalid: " + gurl.spec());
     return;
   }
 
   // Verify we have a valid stream association.
   ActiveStreamMap::iterator associated_it =
       active_streams_.find(associated_stream_id);
-  if (associated_it == active_streams_.end()) {
+  // TODO(jgraettinger): (See PUSH_PROMISE comment above).
+  if (GetProtocolVersion() < SPDY4 && associated_it == active_streams_.end()) {
     EnqueueResetStreamFrame(
         stream_id, request_priority, RST_STREAM_INVALID_STREAM,
         base::StringPrintf(
             "Received OnSyn with inactive associated stream %d",
             associated_stream_id));
     return;
   }
 
   // Check that the SYN 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 via the --trusted-spdy-proxy switch.
   if (trusted_spdy_proxy_.Equals(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",
               associated_stream_id));
     }
-  } else {
+  } else if (GetProtocolVersion() < SPDY4) {
+    // TODO(jgraettinger): (See PUSH_PROMISE comment above).
     GURL associated_url(associated_it->second.stream->GetUrlFromHeaders());
     if (associated_url.GetOrigin() != gurl.GetOrigin()) {
       EnqueueResetStreamFrame(
           stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
           base::StringPrintf(
               "Rejected Cross Origin Push Stream %d",
               associated_stream_id));
       return;
     }
   }
@@ skipping 103 matching lines @@
     // NOTE:  it may just be that the stream was cancelled.
     return;
   }
 
   SpdyStream* stream = it->second.stream;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   stream->IncrementRawReceivedBytes(last_compressed_frame_len_);
   last_compressed_frame_len_ = 0;
 
+  if (GetProtocolVersion() >= SPDY4) {
+    const std::string& error =
+        "SPDY4 wasn't expecting SYN_REPLY.";
+    stream->LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
+    ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, error);
+    return;
+  }
   if (!it->second.waiting_for_syn_reply) {
     const std::string& error =
         "Received duplicate SYN_REPLY for stream.";
     stream->LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-    ResetStreamIterator(it, RST_STREAM_STREAM_IN_USE, error);
+    ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, error);
     return;
   }
   it->second.waiting_for_syn_reply = false;
 
   ignore_result(OnInitialResponseHeadersReceived(
       headers, response_time, recv_first_byte_time, stream));
 }
 
 void SpdySession::OnHeaders(SpdyStreamId stream_id,
                             bool fin,
@@ skipping 16 matching lines @@
     LOG(WARNING) << "Received HEADERS for invalid stream " << stream_id;
     return;
   }
 
   SpdyStream* stream = it->second.stream;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   stream->IncrementRawReceivedBytes(last_compressed_frame_len_);
   last_compressed_frame_len_ = 0;
 
-  int rv = stream->OnAdditionalResponseHeadersReceived(headers);
-  if (rv < 0) {
-    DCHECK_NE(rv, ERR_IO_PENDING);
-    DCHECK(active_streams_.find(stream_id) == active_streams_.end());
+  if (it->second.waiting_for_syn_reply) {
+    if (GetProtocolVersion() < SPDY4) {
+      const std::string& error =
+          "Was expecting SYN_REPLY, not HEADERS.";
+      stream->LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
+      ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, error);
+      return;
+    }
+    base::Time response_time = base::Time::Now();
+    base::TimeTicks recv_first_byte_time = time_func_();
+
+    it->second.waiting_for_syn_reply = false;
+    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());
+    }
   }
 }
 
 void SpdySession::OnRstStream(SpdyStreamId stream_id,
                               SpdyRstStreamStatus status) {
   CHECK(in_io_loop_);
 
   if (availability_state_ == STATE_CLOSED)
     return;
 
@@ skipping 702 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net