Misc cleanup in net/spdy/core.

net/spdy/core/spdy_framer_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/spdy/core/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <tuple>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/platform/api/quic_flags.h"
 #include "net/spdy/chromium/spdy_flags.h"
 #include "net/spdy/core/array_output_buffer.h"
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/mock_spdy_framer_visitor.h"
 #include "net/spdy/core/spdy_frame_builder.h"
 #include "net/spdy/core/spdy_frame_reader.h"
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/core/spdy_test_utils.h"
@@ skipping 400 matching lines @@
     header_stream_id_ = stream_id;
   }
 
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len) override {
     VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len << ", "
             << ")   data:\n"
             << base::HexEncode(data, len);
     EXPECT_EQ(header_stream_id_, stream_id);
+
     data_bytes_ += len;
   }
 
   void OnStreamEnd(SpdyStreamId stream_id) override {
     VLOG(1) << "OnStreamEnd(" << stream_id << ")";
     EXPECT_EQ(header_stream_id_, stream_id);
     ++end_of_stream_count_;
   }
 
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
@@ skipping 18 matching lines @@
       headers_handler_.reset();
     }
   }
 
   void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {
     VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")";
     ++fin_frame_count_;
   }
 
   void OnSetting(SpdySettingsIds id, uint32_t value) override {
-    VLOG(1) << "OnSetting(" << id << ", " << std::hex << ", " << value << ")";
+    VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")";
     ++setting_count_;
   }
 
   void OnSettingsAck() override {
     VLOG(1) << "OnSettingsAck";
     ++settings_ack_received_;
   }
 
   void OnSettingsEnd() override {
     VLOG(1) << "OnSettingsEnd";
@@ skipping 358 matching lines @@
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   SpdySerializedFrame frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers, &output_));
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size() - 2);
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
-  EXPECT_EQ(0u, visitor.headers_.size());
+  EXPECT_THAT(visitor.headers_, testing::IsEmpty());
 }
 
 // Test that we can encode and decode stream dependency values in a header
 // frame.
 TEST_P(SpdyFramerTest, HeaderStreamDependencyValues) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   const SpdyStreamId parent_stream_id_test_array[] = {0, 3};
   for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) {
     const bool exclusive_test_array[] = {true, false};
@@ skipping 183 matching lines @@
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
+
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 // Test that if we receive a DATA with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, DataWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
@@ skipping 57 matching lines @@
 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyRstStreamIR rst_stream_ir(0, ERROR_CODE_PROTOCOL_ERROR);
   SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir));
   if (use_output_) {
-    ASSERT_TRUE(framer.SerializeRstStream(rst_stream_ir, &output_));
+    EXPECT_TRUE(framer.SerializeRstStream(rst_stream_ir, &output_));
     frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
@@ skipping 46 matching lines @@
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
-// Test that if we receive a CONTINUATION with stream ID zero, we signal an
+// Test that if we receive a CONTINUATION with stream ID zero, we signal
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
       SpdyMakeUnique<SpdyString>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializeContinuation(continuation, &output_));
     frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
-// Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
+// Test that if we receive a PUSH_PROMISE with stream ID zero, we signal
 // SPDY_INVALID_STREAM_ID.
 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializePushPromise(
       &framer, push_promise, use_output_ ? &output_ : nullptr));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
-// signal SPDY_INVALID_STREAM_ID.
+// signal SPDY_INVALID_CONTROL_FRAME.
 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializePushPromise(
       &framer, push_promise, use_output_ ? &output_ : nullptr));
 
@@ skipping 28 matching lines @@
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
 
   EXPECT_THAT(visitor.headers_, testing::ElementsAre(testing::Pair(
                                     "name", SpdyStringPiece(value))));
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
-  // See crbug.com/172383
+  // See https://crbug.com/172383/
   SpdyHeadersIR headers(1);
   headers.SetHeader("server", "SpdyServer 1.0");
   headers.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
   headers.SetHeader("status", "200");
   headers.SetHeader("version", "HTTP/1.1");
   headers.SetHeader("content-type", "text/html");
   headers.SetHeader("content-length", "12");
   headers.SetHeader("x-empty-header", "");
 
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
@@ skipping 439 matching lines @@
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     if (use_output_) {
       ASSERT_TRUE(framer.SerializeRstStream(rst_stream, &output_));
       frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
     }
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
+    // clang-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_PROTOCOL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     if (use_output_) {
@@ skipping 22 matching lines @@
     }
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
-
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x06,        // Length: 6
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
         0x0a, 0x0b, 0x0c, 0x0d,  //  Value: 168496141
     };
 
     uint32_t kValue = 0x0a0b0c0d;
@@ skipping 40 matching lines @@
       output_.Reset();
       ASSERT_TRUE(framer.SerializeSettings(settings_ir, &output_));
       frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
     }
 
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
-
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x00,        // Length: 0
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
     };
     SpdySettingsIR settings_ir;
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     if (use_output_) {
       output_.Reset();
@@ skipping 19 matching lines @@
         0x9a, 0xbc, 0xde, 0xff,  //     Data
     };
     const unsigned char kH2FrameDataWithAck[] = {
         0x00, 0x00, 0x08,        // Length: 8
         0x06,                    //   Type: PING
         0x01,                    //  Flags: ACK
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x12, 0x34, 0x56, 0x78,  // Opaque
         0x9a, 0xbc, 0xde, 0xff,  //     Data
     };
-    SpdySerializedFrame frame;
     const SpdyPingId kPingId = 0x123456789abcdeffULL;
     SpdyPingIR ping_ir(kPingId);
     // Tests SpdyPingIR when the ping is not an ack.
     ASSERT_FALSE(ping_ir.is_ack());
-    frame = framer.SerializePing(ping_ir);
+    SpdySerializedFrame frame(framer.SerializePing(ping_ir));
     if (use_output_) {
       ASSERT_TRUE(framer.SerializePing(ping_ir, &output_));
       frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
     }
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 
     // Tests SpdyPingIR when the ping is an ack.
     ping_ir.set_is_ack(true);
     frame = framer.SerializePing(ping_ir);
     if (use_output_) {
@@ skipping 955 matching lines @@
     EXPECT_TRUE(it->HasNextFrame());
     EXPECT_EQ(it->NextFrame(&output_), frame.size());
     EXPECT_FALSE(it->HasNextFrame());
   }
 
  private:
   ArrayOutputBuffer output_;
 };
 
 TEST_F(SpdyControlFrameIteratorTest, RstStreamFrameWithIterator) {
-  auto ir = base::MakeUnique<SpdyRstStreamIR>(0, ERROR_CODE_PROTOCOL_ERROR);
+  auto ir = SpdyMakeUnique<SpdyRstStreamIR>(0, ERROR_CODE_PROTOCOL_ERROR);
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, SettingsFrameWithIterator) {
-  auto ir = base::MakeUnique<SpdySettingsIR>();
+  auto ir = SpdyMakeUnique<SpdySettingsIR>();
   uint32_t kValue = 0x0a0b0c0d;
   SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
   ir->AddSetting(kId, kValue);
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, PingFrameWithIterator) {
   const SpdyPingId kPingId = 0x123456789abcdeffULL;
-  auto ir = base::MakeUnique<SpdyPingIR>(kPingId);
+  auto ir = SpdyMakeUnique<SpdyPingIR>(kPingId);
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, GoAwayFrameWithIterator) {
-  auto ir = base::MakeUnique<SpdyGoAwayIR>(0, ERROR_CODE_NO_ERROR, "GA");
+  auto ir = SpdyMakeUnique<SpdyGoAwayIR>(0, ERROR_CODE_NO_ERROR, "GA");
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, WindowUpdateFrameWithIterator) {
-  auto ir = base::MakeUnique<SpdyWindowUpdateIR>(1, 1);
+  auto ir = SpdyMakeUnique<SpdyWindowUpdateIR>(1, 1);
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, AtlSvcFrameWithIterator) {
-  auto ir = base::MakeUnique<SpdyAltSvcIR>(3);
+  auto ir = SpdyMakeUnique<SpdyAltSvcIR>(3);
   ir->set_origin("origin");
   ir->add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   ir->add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "p\"=i:d", "h_\\o\"st", 123, 42,
       SpdyAltSvcWireFormat::VersionVector{24}));
   RunTest(std::move(ir));
 }
 
 TEST_F(SpdyControlFrameIteratorTest, PriorityFrameWithIterator) {
@@ skipping 107 matching lines @@
   // Zero-len settings frames are permitted as of HTTP/2.
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   SpdySettingsIR settings_ir;
 
   // Add settings to more than fill the frame so that we don't get a buffer
-  // overflow when calling SimulateInFramer() below.  These settings must be
-  // distinct parameters because SpdySettingsIR has a map for settings, and will
-  // collapse multiple copies of the same parameter.
+  // overflow when calling SimulateInFramer() below. These settings must be
+  // distinct parameters because SpdySettingsIR has a map for settings, and
+  // will collapse multiple copies of the same parameter.
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0x00000002);
   settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0x00000002);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializeSettings(settings_ir, &output_));
     control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
   const size_t kNewLength = 8;
   SetFrameLength(&control_frame, kNewLength);
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
@@ skipping 367 matching lines @@
 
   EXPECT_THAT(
       visitor.headers_,
       testing::ElementsAre(testing::Pair("cookie", "foo=bar; baz=bing; "),
                            testing::Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
   // frame-format off
   const unsigned char kInput[] = {
-    0x00, 0x00, 0x17, 0x05,  // PUSH_PROMISE
-    0x08, 0x00, 0x00, 0x00,  // PADDED
-    0x01, 0x02, 0x00, 0x00,  // Stream 1, Pad length field
-    0x00, 0x2A, 0x00, 0x06,  // Promised stream 42
-    'c',  'o',  'o',  'k',
-    'i',  'e',  0x07, 'f',
-    'o',  'o',  '=',  'b',
-    'a',  'r',  0x00, 0x00,
+      0x00, 0x00, 0x17,                       // Length: 23
+      0x05,                                   //   Type: PUSH_PROMISE
+      0x08,                                   //  Flags: PADDED
+      0x00, 0x00, 0x00, 0x01,                 // Stream: 1
+      0x02,                                   // PadLen: 2 trailing bytes
+      0x00, 0x00, 0x00, 0x2a,                 // Promise: 42
+      0x00,                                   // Unindexed Entry
+      0x06,                                   // Name Len: 6
+      'c',  'o',  'o',  'k',  'i', 'e',       // Name
+      0x07,                                   // Value Len: 7
+      'f',  'o',  'o',  '=',  'b', 'a', 'r',  // Value
+      0x00, 0x00,                             // Padding
 
-    0x00, 0x00, 0x14, 0x09,  // CONTINUATION
-    0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x06, 'c',   // Stream 1
-    'o',  'o',  'k',  'i',
-    'e',  0x08, 'b',  'a',
-    'z',  '=',  'b',  'i',
-    'n',  'g',  0x00, 0x06,
-    'c',
+      0x00, 0x00, 0x14,                            // Length: 20
+      0x09,                                        //   Type: CONTINUATION
+      0x00,                                        //  Flags: none
+      0x00, 0x00, 0x00, 0x01,                      // Stream: 1
+      0x00,                                        // Unindexed Entry
+      0x06,                                        // Name Len: 6
+      'c',  'o',  'o',  'k',  'i', 'e',            // Name
+      0x08,                                        // Value Len: 7
+      'b',  'a',  'z',  '=',  'b', 'i', 'n', 'g',  // Value
+      0x00,                                        // Unindexed Entry
+      0x06,                                        // Name Len: 6
+      'c',                                         // Name (split)
 
-    0x00, 0x00, 0x12, 0x09,  // CONTINUATION
-    0x04, 0x00, 0x00, 0x00,  // END_HEADERS
-    0x01, 'o',  'o',  'k',   // Stream 1
-    'i',  'e',  0x00, 0x00,
-    0x04, 'n',  'a',  'm',
-    'e',  0x05, 'v',  'a',
-    'l',  'u',  'e',
+      0x00, 0x00, 0x12,             // Length: 18
+      0x09,                         //   Type: CONTINUATION
+      0x04,                         //  Flags: END_HEADERS
+      0x00, 0x00, 0x00, 0x01,       // Stream: 1
+      'o',  'o',  'k',  'i',  'e',  // Name (continued)
+      0x00,                         // Value Len: 0
+      0x00,                         // Unindexed Entry
+      0x04,                         // Name Len: 4
+      'n',  'a',  'm',  'e',        // Name
+      0x05,                         // Value Len: 5
+      'v',  'a',  'l',  'u',  'e',  // Value
   };
   // frame-format on
 
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_push_promise_stream_);
   EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
@@ skipping 258 matching lines @@
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   if (use_output_) {
     ASSERT_TRUE(framer.SerializeSettings(settings_ir, &output_));
     control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
-  EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
+  EXPECT_EQ(1, visitor.setting_count_);
+  EXPECT_EQ(1, visitor.settings_ack_sent_);
 }
 
 TEST_P(SpdyFramerTest, ReadUnknownExtensionFrameWithExtension) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   // The unrecognized frame type should still have a valid length.
   const unsigned char unknown_frame[] = {
       0x00, 0x00, 0x14,        // Length: 20
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
@@ skipping 17 matching lines @@
 
   // Follow it up with a valid control frame to make sure we handle
   // subsequent frames correctly.
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
-  EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
+  EXPECT_EQ(1, visitor.setting_count_);
+  EXPECT_EQ(1, visitor.settings_ack_sent_);
 }
 
 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
@@ skipping 296 matching lines @@
     }
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(
         &framer, headers_ir, use_output_ ? &output_ : nullptr));
     uint8_t set_flags = flags & ~HEADERS_FLAG_PADDED;
     SetFrameFlags(&frame, set_flags);
 
     // Expected callback values
     SpdyStreamId stream_id = 57;
     bool has_priority = false;
-    SpdyPriority priority = 0;
+    int weight = 0;
     SpdyStreamId parent_stream_id = 0;
     bool exclusive = false;
     bool fin = flags & CONTROL_FLAG_FIN;
     bool end = flags & HEADERS_FLAG_END_HEADERS;
     if (flags & HEADERS_FLAG_PRIORITY) {
       has_priority = true;
-      priority = 3;
+      weight = 3;
       parent_stream_id = 5;
       exclusive = true;
     }
-    EXPECT_CALL(visitor, OnHeaders(stream_id, has_priority, priority,
+    EXPECT_CALL(visitor, OnHeaders(stream_id, has_priority, weight,
                                    parent_stream_id, exclusive, fin, end));
     EXPECT_CALL(visitor, OnHeaderFrameStart(57)).Times(1);
     if (end) {
       EXPECT_CALL(visitor, OnHeaderFrameEnd(57, _)).Times(1);
     }
     if (flags & DATA_FLAG_FIN && end) {
       EXPECT_CALL(visitor, OnStreamEnd(_));
     } else {
       // Do not close the stream if we are expecting a CONTINUATION frame.
       EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
@@ skipping 147 matching lines @@
     }
 
     framer.ProcessInput(frame0.data(), frame0.size());
     framer.ProcessInput(frame1.data(), frame1.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
         << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
   } while (++flags != 0);
 }
 
-// TODO(mlavan): Add TEST_F(SpdyFramerTest, AltSvcFrameFlags)
+// TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
   const unsigned char kH2RstStreamInvalid[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
@@ skipping 283 matching lines @@
     frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false);
   }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
   EXPECT_CALL(visitor, OnPriority(3, 1, 256, false));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
-  // TODO(mlavan): once we actually maintain a priority tree,
-  // check that state is adjusted correctly.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
@@ skipping 222 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net