diff --git a/spdy/core/http2_priority_write_scheduler.h b/spdy/core/http2_priority_write_scheduler.h
index f89dc8d..f64d92b 100644
--- a/spdy/core/http2_priority_write_scheduler.h
+++ b/spdy/core/http2_priority_write_scheduler.h
@@ -406,7 +406,7 @@
   }
 
   if (stream_info->parent == new_parent &&
-      (!exclusive || new_parent->children.size() == 1)) {
+      (!exclusive || new_parent->children.size() == 1u)) {
     // If the new parent is already the stream's parent, and exclusivity (if
     // specified) is already satisfied, we are done.
     return;
@@ -723,8 +723,8 @@
 template <typename StreamIdType>
 bool Http2PriorityWriteScheduler<StreamIdType>::ValidateInvariantsForTests()
     const {
-  int total_streams = 0;
-  int streams_visited = 0;
+  size_t total_streams = 0;
+  size_t streams_visited = 0;
   // Iterate through all streams in the map.
   for (const auto& kv : all_stream_infos_) {
     ++total_streams;
diff --git a/spdy/core/http2_priority_write_scheduler_test.cc b/spdy/core/http2_priority_write_scheduler_test.cc
index 0629de9..bf9f92f 100644
--- a/spdy/core/http2_priority_write_scheduler_test.cc
+++ b/spdy/core/http2_priority_write_scheduler_test.cc
@@ -1,3 +1,7 @@
+// Copyright (c) 2019 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/third_party/quiche/src/spdy/core/http2_priority_write_scheduler.h"
 
 #include <initializer_list>
@@ -74,7 +78,7 @@
   EXPECT_TRUE(scheduler_.StreamRegistered(5));
   ASSERT_TRUE(scheduler_.StreamRegistered(13));
   EXPECT_EQ(130, scheduler_.GetStreamPrecedence(13).weight());
-  EXPECT_EQ(5, scheduler_.GetStreamPrecedence(13).parent_id());
+  EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(13).parent_id());
 
   scheduler_.UnregisterStream(5);
   // Cannot remove a stream that has already been removed.
@@ -88,7 +92,7 @@
   // The parent stream 19 doesn't exist, so this should use 0 as parent stream:
   scheduler_.RegisterStream(7, SpdyStreamPrecedence(19, 70, false));
   EXPECT_TRUE(scheduler_.StreamRegistered(7));
-  EXPECT_EQ(0, scheduler_.GetStreamPrecedence(7).parent_id());
+  EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(7).parent_id());
   // Now stream 7 already exists, so this should fail:
   EXPECT_SPDY_BUG(
       scheduler_.RegisterStream(7, SpdyStreamPrecedence(1, 70, false)),
@@ -105,7 +109,7 @@
 TEST_F(Http2PriorityWriteSchedulerTest, RegisterStreamWithSpdy3Priority) {
   EXPECT_FALSE(scheduler_.StreamRegistered(1));
   scheduler_.RegisterStream(1, SpdyStreamPrecedence(3));
-  EXPECT_EQ(0, scheduler_.NumReadyStreams());
+  EXPECT_EQ(0u, scheduler_.NumReadyStreams());
   EXPECT_TRUE(scheduler_.StreamRegistered(1));
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
   EXPECT_EQ(147, scheduler_.GetStreamPrecedence(1).weight());
@@ -113,7 +117,6 @@
   EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty());
 
   EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
-                  "Expected HTTP/2 stream dependency|"
                   "Stream 1 already registered");
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
 }
@@ -147,7 +150,7 @@
   EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(3).parent_id());
   scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 20, false));
   scheduler_.RegisterStream(3, SpdyStreamPrecedence(2, 30, false));
-  EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).parent_id());
+  EXPECT_EQ(2u, scheduler_.GetStreamPrecedence(3).parent_id());
   scheduler_.UnregisterStream(3);
   EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(3).parent_id());
 }
@@ -609,22 +612,22 @@
   scheduler_.RegisterStream(13, SpdyStreamPrecedence(7, 100, true));
   scheduler_.RegisterStream(14, SpdyStreamPrecedence(7, 100, false));
   scheduler_.UpdateStreamPrecedence(7, SpdyStreamPrecedence(3, 100, false));
-  EXPECT_EQ(0, scheduler_.GetStreamPrecedence(1).parent_id());
-  EXPECT_EQ(0, scheduler_.GetStreamPrecedence(2).parent_id());
-  EXPECT_EQ(0, scheduler_.GetStreamPrecedence(3).parent_id());
-  EXPECT_EQ(1, scheduler_.GetStreamPrecedence(4).parent_id());
-  EXPECT_EQ(1, scheduler_.GetStreamPrecedence(5).parent_id());
-  EXPECT_EQ(2, scheduler_.GetStreamPrecedence(6).parent_id());
-  EXPECT_EQ(3, scheduler_.GetStreamPrecedence(7).parent_id());
-  EXPECT_EQ(4, scheduler_.GetStreamPrecedence(8).parent_id());
-  EXPECT_EQ(4, scheduler_.GetStreamPrecedence(9).parent_id());
-  EXPECT_EQ(5, scheduler_.GetStreamPrecedence(10).parent_id());
-  EXPECT_EQ(5, scheduler_.GetStreamPrecedence(11).parent_id());
-  EXPECT_EQ(6, scheduler_.GetStreamPrecedence(12).parent_id());
-  EXPECT_EQ(7, scheduler_.GetStreamPrecedence(13).parent_id());
-  EXPECT_EQ(7, scheduler_.GetStreamPrecedence(14).parent_id());
-  EXPECT_EQ(8, scheduler_.GetStreamPrecedence(15).parent_id());
-  EXPECT_EQ(8, scheduler_.GetStreamPrecedence(16).parent_id());
+  EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(1).parent_id());
+  EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(2).parent_id());
+  EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(3).parent_id());
+  EXPECT_EQ(1u, scheduler_.GetStreamPrecedence(4).parent_id());
+  EXPECT_EQ(1u, scheduler_.GetStreamPrecedence(5).parent_id());
+  EXPECT_EQ(2u, scheduler_.GetStreamPrecedence(6).parent_id());
+  EXPECT_EQ(3u, scheduler_.GetStreamPrecedence(7).parent_id());
+  EXPECT_EQ(4u, scheduler_.GetStreamPrecedence(8).parent_id());
+  EXPECT_EQ(4u, scheduler_.GetStreamPrecedence(9).parent_id());
+  EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(10).parent_id());
+  EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(11).parent_id());
+  EXPECT_EQ(6u, scheduler_.GetStreamPrecedence(12).parent_id());
+  EXPECT_EQ(7u, scheduler_.GetStreamPrecedence(13).parent_id());
+  EXPECT_EQ(7u, scheduler_.GetStreamPrecedence(14).parent_id());
+  EXPECT_EQ(8u, scheduler_.GetStreamPrecedence(15).parent_id());
+  EXPECT_EQ(8u, scheduler_.GetStreamPrecedence(16).parent_id());
   ASSERT_TRUE(peer_.ValidateInvariants());
 
   EXPECT_EQ(peer_.TotalChildWeights(0),
@@ -727,19 +730,19 @@
   for (int i = 1; i < 6; ++i) {
     scheduler_.MarkStreamReady(i, false);
   }
-  EXPECT_EQ(5, scheduler_.PopNextReadyStream());
-  EXPECT_EQ(2, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(5u, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(2u, scheduler_.PopNextReadyStream());
   scheduler_.MarkStreamReady(2, false);
-  EXPECT_EQ(3, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(3u, scheduler_.PopNextReadyStream());
   scheduler_.MarkStreamReady(3, false);
-  EXPECT_EQ(4, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(4u, scheduler_.PopNextReadyStream());
   scheduler_.MarkStreamReady(4, false);
-  EXPECT_EQ(2, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(2u, scheduler_.PopNextReadyStream());
   scheduler_.MarkStreamReady(2, true);
-  EXPECT_EQ(2, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(2u, scheduler_.PopNextReadyStream());
   scheduler_.MarkStreamReady(5, false);
   scheduler_.MarkStreamReady(2, true);
-  EXPECT_EQ(5, scheduler_.PopNextReadyStream());
+  EXPECT_EQ(5u, scheduler_.PopNextReadyStream());
 }
 
 // Add ready streams at front and back and pop them with
diff --git a/spdy/core/spdy_intrusive_list_test.cc b/spdy/core/spdy_intrusive_list_test.cc
index eee65e3..8577651 100644
--- a/spdy/core/spdy_intrusive_list_test.cc
+++ b/spdy/core/spdy_intrusive_list_test.cc
@@ -72,18 +72,18 @@
 TEST(NewIntrusiveListTest, Basic) {
   TestList list1;
 
-  CHECK_EQ(sizeof(SpdyIntrusiveLink<TestItem>), sizeof(void *) * 2);
+  EXPECT_EQ(sizeof(SpdyIntrusiveLink<TestItem>), sizeof(void*) * 2);
 
   for (int i = 0; i < 10; ++i) {
     TestItem *e = new TestItem;
     e->n = i;
     list1.push_front(e);
   }
-  CHECK_EQ(list1.size(), 10);
+  EXPECT_EQ(list1.size(), 10u);
 
   // Verify we can reverse a list because we defined swap for TestItem.
   std::reverse(list1.begin(), list1.end());
-  CHECK_EQ(list1.size(), 10);
+  EXPECT_EQ(list1.size(), 10u);
 
   // Check both const and non-const forward iteration.
   const TestList& clist1 = list1;
@@ -92,28 +92,28 @@
   for (;
        iter != list1.end();
        ++iter, ++i) {
-    CHECK_EQ(iter->n, i);
+    EXPECT_EQ(iter->n, i);
   }
-  CHECK(iter == clist1.end());
-  CHECK(iter != clist1.begin());
+  EXPECT_EQ(iter, clist1.end());
+  EXPECT_NE(iter, clist1.begin());
   i = 0;
   iter = list1.begin();
   for (;
        iter != list1.end();
        ++iter, ++i) {
-    CHECK_EQ(iter->n, i);
+    EXPECT_EQ(iter->n, i);
   }
-  CHECK(iter == clist1.end());
-  CHECK(iter != clist1.begin());
+  EXPECT_EQ(iter, clist1.end());
+  EXPECT_NE(iter, clist1.begin());
 
-  CHECK_EQ(list1.front().n, 0);
-  CHECK_EQ(list1.back().n, 9);
+  EXPECT_EQ(list1.front().n, 0);
+  EXPECT_EQ(list1.back().n, 9);
 
   // Verify we can swap 2 lists.
   TestList list2;
   list2.swap(list1);
-  CHECK_EQ(list1.size(), 0);
-  CHECK_EQ(list2.size(), 10);
+  EXPECT_EQ(list1.size(), 0u);
+  EXPECT_EQ(list2.size(), 10u);
 
   // Check both const and non-const reverse iteration.
   const TestList& clist2 = list2;
@@ -122,20 +122,20 @@
   for (;
        riter != list2.rend();
        ++riter, --i) {
-    CHECK_EQ(riter->n, i);
+    EXPECT_EQ(riter->n, i);
   }
-  CHECK(riter == clist2.rend());
-  CHECK(riter != clist2.rbegin());
+  EXPECT_EQ(riter, clist2.rend());
+  EXPECT_NE(riter, clist2.rbegin());
 
   riter = list2.rbegin();
   i = 9;
   for (;
        riter != list2.rend();
        ++riter, --i) {
-    CHECK_EQ(riter->n, i);
+    EXPECT_EQ(riter->n, i);
   }
-  CHECK(riter == clist2.rend());
-  CHECK(riter != clist2.rbegin());
+  EXPECT_EQ(riter, clist2.rend());
+  EXPECT_NE(riter, clist2.rbegin());
 
   while (!list2.empty()) {
     TestItem *e = &list2.front();
@@ -156,12 +156,12 @@
 
   // Test that erase works.
   for (int i = 0; i < 10; ++i) {
-    CHECK_EQ(l.size(), (10 - i));
+    EXPECT_EQ(l.size(), (10u - i));
 
     TestList::iterator iter = l.erase(e[i]);
-    CHECK(iter != TestList::iterator(e[i]));
+    EXPECT_NE(iter, TestList::iterator(e[i]));
 
-    CHECK_EQ(l.size(), (10 - i - 1));
+    EXPECT_EQ(l.size(), (10u - i - 1));
     delete e[i];
   }
 }
@@ -175,15 +175,15 @@
   for (int i = 9; i >= 0; --i) {
     e[i] = new TestItem;
     iter = l.insert(iter, e[i]);
-    CHECK_EQ(&(*iter), e[i]);
+    EXPECT_EQ(&(*iter), e[i]);
   }
 
-  CHECK_EQ(l.size(), 10);
+  EXPECT_EQ(l.size(), 10u);
 
   // Verify insertion order.
   iter = l.begin();
   for (TestItem *item : e) {
-    CHECK_EQ(&(*iter), item);
+    EXPECT_EQ(&(*iter), item);
     iter = l.erase(item);
     delete item;
   }
@@ -264,7 +264,7 @@
 
             CheckLists();
 
-            ASSERT_EQ(3, secondary_list.size());
+            ASSERT_EQ(3u, secondary_list.size());
             for (int i = 0; i < 3; ++i) {
               EXPECT_EQ(&e[i], &*std::next(secondary_list.begin(), i));
             }
@@ -338,11 +338,11 @@
     DerivedClass elements[2];
     EXPECT_TRUE(list.empty());
     list.push_back(&elements[0]);
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.push_back(&elements[1]);
-    EXPECT_EQ(2, list.size());
+    EXPECT_EQ(2u, list.size());
     list.pop_back();
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.pop_back();
     EXPECT_TRUE(list.empty());
   }
@@ -351,11 +351,11 @@
     VirtuallyDerivedClassA elements[2];
     EXPECT_TRUE(list.empty());
     list.push_back(&elements[0]);
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.push_back(&elements[1]);
-    EXPECT_EQ(2, list.size());
+    EXPECT_EQ(2u, list.size());
     list.pop_back();
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.pop_back();
     EXPECT_TRUE(list.empty());
   }
@@ -364,11 +364,11 @@
     VirtuallyDerivedClassC elements[2];
     EXPECT_TRUE(list.empty());
     list.push_back(&elements[0]);
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.push_back(&elements[1]);
-    EXPECT_EQ(2, list.size());
+    EXPECT_EQ(2u, list.size());
     list.pop_back();
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.pop_back();
     EXPECT_TRUE(list.empty());
   }
@@ -380,13 +380,13 @@
     VirtuallyDerivedClassC d4;
     EXPECT_TRUE(list.empty());
     list.push_back(&d1);
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.push_back(&d2);
-    EXPECT_EQ(2, list.size());
+    EXPECT_EQ(2u, list.size());
     list.push_back(&d3);
-    EXPECT_EQ(3, list.size());
+    EXPECT_EQ(3u, list.size());
     list.push_back(&d4);
-    EXPECT_EQ(4, list.size());
+    EXPECT_EQ(4u, list.size());
     SpdyIntrusiveList<AbstractBase, BaseLinkId>::iterator it = list.begin();
     EXPECT_EQ("DerivedClass",           (it++)->name());
     EXPECT_EQ("VirtuallyDerivedClassA", (it++)->name());
@@ -398,11 +398,11 @@
     templated_base_link::DerivedClass elements[2];
     EXPECT_TRUE(list.empty());
     list.push_back(&elements[0]);
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.push_back(&elements[1]);
-    EXPECT_EQ(2, list.size());
+    EXPECT_EQ(2u, list.size());
     list.pop_back();
-    EXPECT_EQ(1, list.size());
+    EXPECT_EQ(1u, list.size());
     list.pop_back();
     EXPECT_TRUE(list.empty());
   }