Use the right priority when marking QUIC streams write blocked via

net/quic/quic_session_test.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/quic/quic_session.h"
 
 #include <set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 14 matching lines @@
 using std::vector;
 using testing::_;
 using testing::InSequence;
 using testing::InvokeWithoutArgs;
 using testing::StrictMock;
 
 namespace net {
 namespace test {
 namespace {
 
-const QuicPriority kSomeMiddlePriority = 2;
+const QuicPriority kHighestPriority = 0;
+const QuicPriority kSomeMiddlePriority = 3;
 
 class TestCryptoStream : public QuicCryptoStream {
  public:
   explicit TestCryptoStream(QuicSession* session)
       : QuicCryptoStream(session) {
   }
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     encryption_established_ = true;
@@ skipping 226 matching lines @@
     const char data[] =
         "\0\0\0\0"   // priority
         "\1\0\0\0"   // headers id
         "\0\0\0\4"   // length
         "abcd";      // invalid compressed data
     EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
     stream->ProcessRawData(data, arraysize(data));
   }
 }
 
+TEST_P(QuicSessionTest, DebugDFatalIfMarkingClosedStreamWriteBlocked) {
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
+  // Close the stream.
+  stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
+  // TODO(rtenneti): enable when chromium supports EXPECT_DEBUG_DFATAL.
+  /*
+  QuicStreamId kClosedStreamId = stream2->id();
+  EXPECT_DEBUG_DFATAL(
+      session_.MarkWriteBlocked(kClosedStreamId, kSomeMiddlePriority),
+      "Marking unknown stream 2 blocked.");
+  */
+}
+
+TEST_P(QuicSessionTest, DebugDFatalIfMarkWriteBlockedCalledWithWrongPriority) {
+  const QuicPriority kDifferentPriority = 0;
+
+  TestStream* stream2 = session_.CreateOutgoingDataStream();
+  EXPECT_NE(kDifferentPriority, stream2->EffectivePriority());
+  // TODO(rtenneti): enable when chromium supports EXPECT_DEBUG_DFATAL.
+  /*
+  EXPECT_DEBUG_DFATAL(
+      session_.MarkWriteBlocked(stream2->id(), kDifferentPriority),
+      "Priorities do not match.  Got: 0 Expected: 3");
+  */
+}
+
 TEST_P(QuicSessionTest, OnCanWrite) {
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   TestStream* stream4 = session_.CreateOutgoingDataStream();
   TestStream* stream6 = session_.CreateOutgoingDataStream();
 
   session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
   session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
 
   InSequence s;
@@ skipping 15 matching lines @@
   StreamBlocker stream2_blocker(&session_, stream2->id());
   stream2_blocker.MarkWriteBlocked();
   EXPECT_FALSE(session_.HasPendingHandshake());
 
   TestStream* stream3 = session_.CreateOutgoingDataStream();
   StreamBlocker stream3_blocker(&session_, stream3->id());
   stream3_blocker.MarkWriteBlocked();
   EXPECT_FALSE(session_.HasPendingHandshake());
 
   // Blocking (due to buffering of) the Crypto stream is detected.
-  session_.MarkWriteBlocked(kCryptoStreamId, kSomeMiddlePriority);
+  session_.MarkWriteBlocked(kCryptoStreamId, kHighestPriority);
   EXPECT_TRUE(session_.HasPendingHandshake());
 
   TestStream* stream4 = session_.CreateOutgoingDataStream();
   StreamBlocker stream4_blocker(&session_, stream4->id());
   stream4_blocker.MarkWriteBlocked();
   EXPECT_TRUE(session_.HasPendingHandshake());
 
   InSequence s;
   // Force most streams to re-register, which is common scenario when we block
   // the Crypto stream, and only the crypto stream can "really" write.
@@ skipping 176 matching lines @@
   }
 
   QuicRstStreamFrame rst1(stream_id1, QUIC_STREAM_NO_ERROR);
   session_.OnRstStream(rst1);
   EXPECT_EQ(0u, session_.GetNumOpenStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net