Introduce STATE_RESERVED_REMOTE. No behavioral changes

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 246 matching lines @@
       : request_(request) {}
 
   bool operator()(const base::WeakPtr<SpdyStreamRequest>& request) const {
     return request_.get() == request.get();
   }
 
  private:
   const base::WeakPtr<SpdyStreamRequest> request_;
 };
 
+// Splits headers received in SYN_STREAM into request and response headers.
+void GetPushPromiseHeadersFromSynStream(SpdyHeaderBlock* response_headers,
+                                        SpdyHeaderBlock* request_headers,
+                                        SpdyMajorVersion protocol_version) {
+  DCHECK(response_headers);
+  DCHECK(request_headers);
+
+  // SPDY 2 server push urls are specified in a single "url" header.
+  if (protocol_version == SPDY2) {
+    SpdyHeaderBlock::iterator it;
+    it = response_headers->find("url");
+    if (it != response_headers->end()) {
+      (*request_headers)["url"] = it->second;
+      response_headers->erase(it);
+    }
+    return;
+  }
+
+  DCHECK_LT(SPDY2, protocol_version);
+  static const char* kRequestHeaders[] = { ":scheme", ":host", ":path" };

[Johnny, 2014/06/05 02:56:04]

Also :authority (instead of :host) for HTTP/2.

nit: Use git cl format for things like the extra spaces within {}.

[baranovich, 2014/06/05 19:16:58]

Done.

+  SpdyHeaderBlock::iterator it;
+  for (size_t i = 0; i < arraysize(kRequestHeaders); ++i) {
+    it = response_headers->find(kRequestHeaders[i]);
+    if (it != response_headers->end()) {
+      (*request_headers)[kRequestHeaders[i]] = it->second;
+      response_headers->erase(it);
+    }
+  }

[Johnny, 2014/06/05 02:56:04]

Can we add unit testing on this in SpdySessionTest?

[baranovich, 2014/06/05 19:16:58]

Done.

+}
+
 // The maximum number of concurrent streams we will ever create.  Even if
 // the server permits more, we will never exceed this limit.
 const size_t kMaxConcurrentStreamLimit = 256;
 
 }  // namespace
 
 SpdyProtocolErrorDetails MapFramerErrorToProtocolError(
     SpdyFramer::SpdyError err) {
   switch(err) {
     case SpdyFramer::SPDY_NO_ERROR:
@@ skipping 1842 matching lines @@
 
   InsertActivatedStream(stream.Pass());
 
   ActiveStreamMap::iterator active_it = active_streams_.find(stream_id);
   if (active_it == active_streams_.end()) {
     NOTREACHED();
     return;
   }
 
   // Parse the headers.
+
+  // Split headers to simulate push promise and response.
+  SpdyHeaderBlock request_headers;
+  SpdyHeaderBlock response_headers(headers);
+  GetPushPromiseHeadersFromSynStream(&response_headers,

[Johnny, 2014/06/05 02:56:04]

Since we're copying here anyway, how about passing in headers as a const
reference, and request & response headers as output arguments?

Consider a name for the method which more concisely conveys it's function
(extracting request vs response headers), rather than it's use (for push-promise
vs syn-stream frames).

[baranovich, 2014/06/05 19:16:57]

Done.
That's the best name I've come up to;) maybe you'll suggest better one, my
english is poor=)

+                                     &request_headers,
+                                     GetProtocolVersion());
+
+  if (active_it->second.stream->
+          OnPushPromiseHeadersReceived(request_headers) != OK)
+    return;
+
   if (OnInitialResponseHeadersReceived(
-          headers, response_time,
+          response_headers, response_time,
           recv_first_byte_time, active_it->second.stream) != OK)
     return;
 
   base::StatsCounter push_requests("spdy.pushed_streams");
   push_requests.Increment();
 }
 
 void SpdySession::DeleteExpiredPushedStreams() {
   if (unclaimed_pushed_streams_.empty())
     return;
@@ skipping 803 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net