Initial implementation of RequestPriority-based HTTP/2 dependencies.

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 
@@ skipping 716 matching lines @@
 }
 
 void SpdySessionPoolPeer::SetSessionMaxRecvWindowSize(size_t window) {
   pool_->session_max_recv_window_size_ = window;
 }
 
 void SpdySessionPoolPeer::SetStreamInitialRecvWindowSize(size_t window) {
   pool_->stream_max_recv_window_size_ = window;
 }
 
-SpdyTestUtil::SpdyTestUtil(NextProto protocol)
+SpdyTestUtil::SpdyTestUtil(NextProto protocol, bool dependency_priorities)
     : protocol_(protocol),
       spdy_version_(NextProtoToSpdyMajorVersion(protocol)),
-      default_url_(GURL(kDefaultURL)) {
+      default_url_(GURL(kDefaultURL)),
+      dependency_priorities_(dependency_priorities) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
 
+SpdyTestUtil::~SpdyTestUtil() {}
+
 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
                                        SpdyHeaderBlock* headers) const {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   (*headers)[GetHostKey()] = host;
   (*headers)[GetSchemeKey()] = scheme;
   (*headers)[GetPathKey()] = path;
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
@@ skipping 374 matching lines @@
   AppendToHeaderBlock(headers, header_count,
                       spdy_headers.mutable_header_block());
   return CreateFramer(false)->SerializeFrame(spdy_headers);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
                                           const SpdyHeaderBlock& block,
                                           RequestPriority priority,
                                           bool compressed,
                                           bool fin) const {
+  // Get the stream id of the next highest priority request
+  // (most recent request of the same priority, or last request of
+  // an earlier priority).
+  int parent_stream_id = 0;
+  for (int q = priority; q >= IDLE; --q) {
+    if (!priority_to_stream_id_list_[q].empty()) {
+      parent_stream_id = priority_to_stream_id_list_[q].back();
+      break;
+    }
+  }
+
+  priority_to_stream_id_list_[priority].push_back(stream_id);
+
   if (protocol_ < kProtoHTTP2) {
     SpdySynStreamIR syn_stream(stream_id);
     syn_stream.set_header_block(block);
     syn_stream.set_priority(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
     syn_stream.set_fin(fin);
     return CreateFramer(compressed)->SerializeFrame(syn_stream);
   } else {
     SpdyHeadersIR headers(stream_id);
     headers.set_header_block(block);
     headers.set_has_priority(true);
     headers.set_priority(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
+    if (dependency_priorities_) {
+      headers.set_parent_stream_id(parent_stream_id);
+      headers.set_exclusive(true);
+    }
     headers.set_fin(fin);
     return CreateFramer(compressed)->SerializeFrame(headers);
   }
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
                                             const SpdyHeaderBlock& headers) {
   if (protocol_ < kProtoHTTP2) {
     SpdySynReplyIR syn_reply(stream_id);
     syn_reply.set_header_block(headers);
@@ skipping 104 matching lines @@
   return framer.SerializeData(data_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
     const scoped_ptr<SpdyFrame>& frame,
     int stream_id) {
   return ConstructSpdyBodyFrame(stream_id, frame->data(),
                                 frame->size(), false);
 }
 
+void SpdyTestUtil::OnStreamDestruction(int stream_id) {
+  LOG(ERROR) << __FUNCTION__ << " stream_id " << stream_id;

[Bence, 2015/11/11 18:47:15]

I assume you do not intend to keep these LOG statements, right?

[Randy Smith (Not in Mondays), 2015/11/11 23:25:59]

Whoops, I was trying to keep these in the git stash.  Done.

+  for (auto priority_it = priority_to_stream_id_list_.begin();
+       priority_it != priority_to_stream_id_list_.end(); ++priority_it) {
+    for (auto stream_it = priority_it->second.begin();
+         stream_it != priority_it->second.end(); ++stream_it) {
+      if (*stream_it == stream_id) {
+        LOG(ERROR) << __FUNCTION__ << ":" << __LINE__ << " vector size "
+                   << priority_it->second.size();
+        priority_it->second.erase(stream_it);
+        LOG(ERROR) << __FUNCTION__ << ":" << __LINE__ << " vector size "
+                   << priority_it->second.size();
+        return;
+      }
+    }
+  }
+  LOG(ERROR) << __FUNCTION__ << "Reached end.";
+  NOTREACHED();
+}
+
 const SpdyHeaderInfo SpdyTestUtil::MakeSpdyHeader(SpdyFrameType type) {
   const SpdyHeaderInfo kHeader = {
     type,
     1,                            // Stream ID
     0,                            // Associated stream ID
     ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
     kSpdyCredentialSlotUnused,
     CONTROL_FLAG_FIN,             // Control Flags
     false,                        // Compressed
     RST_STREAM_INVALID,
@@ skipping 71 matching lines @@
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net