Add convenience HighestPriority and LowestPriority methods to QuicUtils.

net/quic/quic_data_stream_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_data_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
@@ skipping 99 matching lines @@
   scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<QuicSpdyDecompressor> decompressor_;
   SpdyHeaderBlock headers_;
   WriteBlockedList<QuicStreamId>* write_blocked_list_;
 };
 
 TEST_F(QuicDataStreamTest, ProcessHeaders) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_), stream_->data());
-  EXPECT_EQ(static_cast<QuicPriority>(kHighestPriority),
-            stream_->EffectivePriority());
+  EXPECT_EQ(QuicUtils::HighestPriority(), stream_->EffectivePriority());
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidHeaderId) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   compressed_headers[4] = '\xFF';  // Illegal  header id.
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
 
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidPriority) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   compressed_headers[0] = '\xFF';  // Illegal priority.
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
 
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_PRIORITY));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersAndBody) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
             stream_->data());
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyFragments) {
   Initialize(kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kLowestPriority, headers_);
+      QuicUtils::LowestPriority(), headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
 
   for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) {
     Initialize(kShouldProcessData);
     for (size_t offset = 0; offset < data.size(); offset += fragment_size) {
       size_t remaining_data = data.length() - offset;
       StringPiece fragment(data.data() + offset,
                            min(fragment_size, remaining_data));
       QuicStreamFrame frame(kStreamId, false, offset, MakeIOVector(fragment));
@@ skipping 12 matching lines @@
     stream_->OnStreamFrame(frame1);
 
     StringPiece fragment2(data.data() + split_point, data.size() - split_point);
     QuicStreamFrame frame2(
         kStreamId, false, split_point, MakeIOVector(fragment2));
     stream_->OnStreamFrame(frame2);
 
     ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
               stream_->data()) << "split_point: " << split_point;
   }
-  EXPECT_EQ(static_cast<QuicPriority>(kLowestPriority),
-            stream_->EffectivePriority());
+  EXPECT_EQ(QuicUtils::LowestPriority(), stream_->EffectivePriority());
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyReadv) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
   string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   string uncompressed_data = uncompressed_headers + body;
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(uncompressed_headers, stream_->data());
 
   char buffer[2048];
   ASSERT_LT(data.length(), arraysize(buffer));
   struct iovec vec;
   vec.iov_base = buffer;
   vec.iov_len = arraysize(buffer);
 
   size_t bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(uncompressed_headers.length(), bytes_read);
   EXPECT_EQ(uncompressed_headers, string(buffer, bytes_read));
 
   bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(body.length(), bytes_read);
   EXPECT_EQ(body, string(buffer, bytes_read));
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
   string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   string uncompressed_data = uncompressed_headers + body;
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(uncompressed_headers, stream_->data());
 
   char buffer[1];
   struct iovec vec;
   vec.iov_base = buffer;
   vec.iov_len = arraysize(buffer);
   for (size_t i = 0; i < uncompressed_data.length(); ++i) {
     size_t bytes_read = stream_->Readv(&vec, 1);
     ASSERT_EQ(1u, bytes_read);
     EXPECT_EQ(uncompressed_data.data()[i], buffer[0]);
   }
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
   QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
   string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   string uncompressed_data = uncompressed_headers + body;
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(uncompressed_headers, stream_->data());
 
   char buffer1[1];
   char buffer2[1];
   struct iovec vec[2];
   vec[0].iov_base = buffer1;
   vec[0].iov_len = arraysize(buffer1);
   vec[1].iov_base = buffer2;
   vec[1].iov_len = arraysize(buffer2);
   for (size_t i = 0; i < uncompressed_data.length(); i += 2) {
     size_t bytes_read = stream_->Readv(vec, 2);
     ASSERT_EQ(2u, bytes_read) << i;
     ASSERT_EQ(uncompressed_data.data()[i], buffer1[0]) << i;
     ASSERT_EQ(uncompressed_data.data()[i + 1], buffer2[0]) << i;
   }
 }
 
 TEST_F(QuicDataStreamTest, ProcessCorruptHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame1(
       stream_->id(), false, 0, MakeIOVector(compressed_headers1));
   string decompressed_headers1 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   headers_["content-type"] = "text/plain";
   string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   // Corrupt the compressed data.
   compressed_headers2[compressed_headers2.length() - 1] ^= 0xA1;
   QuicStreamFrame frame2(
       stream2_->id(), false, 0, MakeIOVector(compressed_headers2));
   string decompressed_headers2 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   // Deliver frame2 to stream2 out of order.  The decompressor is not
   // available yet, so no data will be processed.  The compressed data
   // will be buffered until OnDecompressorAvailable() is called
@@ skipping 13 matching lines @@
   EXPECT_EQ(2u, session_->decompressor()->current_header_id());
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
   stream2_->OnDecompressorAvailable();
   EXPECT_EQ("", stream2_->data());
 }
 
 TEST_F(QuicDataStreamTest, ProcessPartialHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame1(
       stream_->id(), false, 0, MakeIOVector(compressed_headers1));
   string decompressed_headers1 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   headers_["content-type"] = "text/plain";
   string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   string partial_compressed_headers =
       compressed_headers2.substr(0, compressed_headers2.length() / 2);
   QuicStreamFrame frame2(
       stream2_->id(), false, 0, MakeIOVector(partial_compressed_headers));
   string decompressed_headers2 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   // Deliver frame2 to stream2 out of order.  The decompressor is not
   // available yet, so no data will be processed.  The compressed data
   // will be buffered until OnDecompressorAvailable() is called
@@ skipping 24 matching lines @@
                          partial_compressed_headers.length(),
                          MakeIOVector(remaining_compressed_headers));
   stream2_->OnStreamFrame(frame3);
   EXPECT_EQ(decompressed_headers2, stream2_->data());
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame1(
       stream_->id(), false, 0, MakeIOVector(compressed_headers1));
   string decompressed_headers1 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   headers_["content-type"] = "text/plain";
   string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame2(
       stream2_->id(), false, 0, MakeIOVector(compressed_headers2));
   string decompressed_headers2 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   // Deliver frame2 to stream2 out of order.  The decompressor is not
   // available yet, so no data will be processed.  The compressed data
   // will be buffered until OnDecompressorAvailable() is called
   // to process it.
   stream2_->OnStreamFrame(frame2);
   EXPECT_EQ("", stream2_->data());
 
   // Now deliver frame1 to stream1.  The decompressor is available so
   // the data will be processed, and the decompressor will become
   // available for stream2.
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(decompressed_headers1, stream_->data());
 
   // Verify that the decompressor is available, and inform stream2
   // that it can now decompress the buffered compressed data.
   EXPECT_EQ(2u, session_->decompressor()->current_header_id());
   stream2_->OnDecompressorAvailable();
   EXPECT_EQ(decompressed_headers2, stream2_->data());
 }
 
 TEST_F(QuicDataStreamTest, ProcessHeadersDelay) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
+      QuicUtils::HighestPriority(), headers_);
   QuicStreamFrame frame1(
       stream_->id(), false, 0, MakeIOVector(compressed_headers));
   string decompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   // Send the headers to the stream and verify they were decompressed.
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(2u, session_->decompressor()->current_header_id());
 
   // Verify that we are now able to handle the body data,
   // even though the stream has not processed the headers.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
       .Times(0);
   QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
                          MakeIOVector("body data"));
   stream_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net