@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/http2/core/http2_trace_logging.cc

@@ -257,16 +257,17 @@ bool Http2TraceLogger::OnGoAwayFrameData(const char* goaway_data, size_t len) {
   return wrapped_->OnGoAwayFrameData(goaway_data, len);
 }
 
-void Http2TraceLogger::OnHeaders(SpdyStreamId stream_id, bool has_priority,
-                                 int weight, SpdyStreamId parent_stream_id,
-                                 bool exclusive, bool fin, bool end) {
+void Http2TraceLogger::OnHeaders(SpdyStreamId stream_id, size_t payload_length,
+                                 bool has_priority, int weight,
+                                 SpdyStreamId parent_stream_id, bool exclusive,
+                                 bool fin, bool end) {
   HTTP2_TRACE_LOG(perspective_, is_enabled_)
       << "OnHeaders:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id)
-      << FORMAT_ARG(has_priority) << FORMAT_INT_ARG(weight)
-      << FORMAT_ARG(parent_stream_id) << FORMAT_ARG(exclusive)
-      << FORMAT_ARG(fin) << FORMAT_ARG(end);
-  wrapped_->OnHeaders(stream_id, has_priority, weight, parent_stream_id,
-                      exclusive, fin, end);
+      << FORMAT_ARG(payload_length) << FORMAT_ARG(has_priority)
+      << FORMAT_INT_ARG(weight) << FORMAT_ARG(parent_stream_id)
+      << FORMAT_ARG(exclusive) << FORMAT_ARG(fin) << FORMAT_ARG(end);
+  wrapped_->OnHeaders(stream_id, payload_length, has_priority, weight,
+                      parent_stream_id, exclusive, fin, end);
 }
 
 void Http2TraceLogger::OnWindowUpdate(SpdyStreamId stream_id,
@@ -287,11 +288,12 @@ void Http2TraceLogger::OnPushPromise(SpdyStreamId original_stream_id,
   wrapped_->OnPushPromise(original_stream_id, promised_stream_id, end);
 }
 
-void Http2TraceLogger::OnContinuation(SpdyStreamId stream_id, bool end) {
+void Http2TraceLogger::OnContinuation(SpdyStreamId stream_id,
+                                      size_t payload_length, bool end) {
   HTTP2_TRACE_LOG(perspective_, is_enabled_)
       << "OnContinuation:" << FORMAT_ARG(connection_id_)
-      << FORMAT_ARG(stream_id) << FORMAT_ARG(end);
-  wrapped_->OnContinuation(stream_id, end);
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(payload_length) << FORMAT_ARG(end);
+  wrapped_->OnContinuation(stream_id, payload_length, end);
 }
 
 void Http2TraceLogger::OnAltSvc(

package/third_party/quiche/quiche/http2/core/http2_trace_logging.h

@@ -71,13 +71,14 @@ class QUICHE_EXPORT_PRIVATE Http2TraceLogger
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
                 SpdyErrorCode error_code) override;
   bool OnGoAwayFrameData(const char* goaway_data, size_t len) override;
-  void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
-                 SpdyStreamId parent_stream_id, bool exclusive, bool fin,
-                 bool end) override;
+  void OnHeaders(SpdyStreamId stream_id, size_t payload_length,
+                 bool has_priority, int weight, SpdyStreamId parent_stream_id,
+                 bool exclusive, bool fin, bool end) override;
   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override;
   void OnPushPromise(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                      bool end) override;
-  void OnContinuation(SpdyStreamId stream_id, bool end) override;
+  void OnContinuation(SpdyStreamId stream_id, size_t payload_length,
+                      bool end) override;
   void OnAltSvc(SpdyStreamId stream_id, absl::string_view origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override;

package/third_party/quiche/quiche/http2/core/priority_write_scheduler.h

@@ -8,12 +8,13 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <tuple>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "quiche/http2/core/write_scheduler.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
@@ -66,9 +67,11 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
           << "Stream " << root_stream_id_ << " already registered";
       return;
     }
-    StreamInfo stream_info = {precedence.spdy3_priority(), stream_id, false};
+    auto stream_info = std::make_unique<StreamInfo>(
+        StreamInfo{precedence.spdy3_priority(), stream_id, false});
     bool inserted =
-        stream_infos_.insert(std::make_pair(stream_id, stream_info)).second;
+        stream_infos_.insert(std::make_pair(stream_id, std::move(stream_info)))
+            .second;
     QUICHE_BUG_IF(spdy_bug_19_2, !inserted)
         << "Stream " << stream_id << " already registered";
   }
@@ -79,10 +82,10 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_BUG(spdy_bug_19_3) << "Stream " << stream_id << " not registered";
       return;
     }
-    StreamInfo& stream_info = it->second;
-    if (stream_info.ready) {
-      bool erased =
-          Erase(&priority_infos_[stream_info.priority].ready_list, stream_info);
+    const StreamInfo* const stream_info = it->second.get();
+    if (stream_info->ready) {
+      bool erased = Erase(&priority_infos_[stream_info->priority].ready_list,
+                          stream_info);
       QUICHE_DCHECK(erased);
     }
     stream_infos_.erase(it);
@@ -99,7 +102,7 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered";
       return StreamPrecedenceType(spdy::kV3LowestPriority);
     }
-    return StreamPrecedenceType(it->second.priority);
+    return StreamPrecedenceType(it->second->priority);
   }
 
   void UpdateStreamPrecedence(StreamIdType stream_id,
@@ -120,19 +123,19 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered";
       return;
     }
-    StreamInfo& stream_info = it->second;
+    StreamInfo* const stream_info = it->second.get();
     spdy::SpdyPriority new_priority = precedence.spdy3_priority();
-    if (stream_info.priority == new_priority) {
+    if (stream_info->priority == new_priority) {
       return;
     }
-    if (stream_info.ready) {
-      bool erased =
-          Erase(&priority_infos_[stream_info.priority].ready_list, stream_info);
+    if (stream_info->ready) {
+      bool erased = Erase(&priority_infos_[stream_info->priority].ready_list,
+                          stream_info);
       QUICHE_DCHECK(erased);
-      priority_infos_[new_priority].ready_list.push_back(&stream_info);
+      priority_infos_[new_priority].ready_list.push_back(stream_info);
       ++num_ready_streams_;
     }
-    stream_info.priority = new_priority;
+    stream_info->priority = new_priority;
   }
 
   std::vector<StreamIdType> GetStreamChildren(
@@ -147,7 +150,7 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_BUG(spdy_bug_19_4) << "Stream " << stream_id << " not registered";
       return;
     }
-    PriorityInfo& priority_info = priority_infos_[it->second.priority];
+    PriorityInfo& priority_info = priority_infos_[it->second->priority];
     priority_info.last_event_time_usec =
         std::max(priority_info.last_event_time_usec, now_in_usec);
   }
@@ -159,9 +162,9 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       return 0;
     }
     int64_t last_event_time_usec = 0;
-    const StreamInfo& stream_info = it->second;
+    const StreamInfo* const stream_info = it->second.get();
     for (spdy::SpdyPriority p = spdy::kV3HighestPriority;
-         p < stream_info.priority; ++p) {
+         p < stream_info->priority; ++p) {
       last_event_time_usec = std::max(last_event_time_usec,
                                       priority_infos_[p].last_event_time_usec);
     }
@@ -179,7 +182,7 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
          p <= spdy::kV3LowestPriority; ++p) {
       ReadyList& ready_list = priority_infos_[p].ready_list;
       if (!ready_list.empty()) {
-        StreamInfo* info = ready_list.front();
+        StreamInfo* const info = ready_list.front();
         ready_list.pop_front();
         --num_ready_streams_;
 
@@ -202,9 +205,9 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
     }
 
     // If there's a higher priority stream, this stream should yield.
-    const StreamInfo& stream_info = it->second;
+    const StreamInfo* const stream_info = it->second.get();
     for (spdy::SpdyPriority p = spdy::kV3HighestPriority;
-         p < stream_info.priority; ++p) {
+         p < stream_info->priority; ++p) {
       if (!priority_infos_[p].ready_list.empty()) {
         return true;
       }
@@ -212,7 +215,7 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
 
     // If this priority level is empty, or this stream is the next up, there's
     // no need to yield.
-    const auto& ready_list = priority_infos_[it->second.priority].ready_list;
+    const auto& ready_list = priority_infos_[it->second->priority].ready_list;
     if (ready_list.empty() || ready_list.front()->stream_id == stream_id) {
       return false;
     }
@@ -228,18 +231,18 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_BUG(spdy_bug_19_8) << "Stream " << stream_id << " not registered";
       return;
     }
-    StreamInfo& stream_info = it->second;
-    if (stream_info.ready) {
+    StreamInfo* const stream_info = it->second.get();
+    if (stream_info->ready) {
       return;
     }
-    ReadyList& ready_list = priority_infos_[stream_info.priority].ready_list;
+    ReadyList& ready_list = priority_infos_[stream_info->priority].ready_list;
     if (add_to_front) {
-      ready_list.push_front(&stream_info);
+      ready_list.push_front(stream_info);
     } else {
-      ready_list.push_back(&stream_info);
+      ready_list.push_back(stream_info);
     }
     ++num_ready_streams_;
-    stream_info.ready = true;
+    stream_info->ready = true;
   }
 
   void MarkStreamNotReady(StreamIdType stream_id) override {
@@ -248,14 +251,14 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_BUG(spdy_bug_19_9) << "Stream " << stream_id << " not registered";
       return;
     }
-    StreamInfo& stream_info = it->second;
-    if (!stream_info.ready) {
+    StreamInfo* const stream_info = it->second.get();
+    if (!stream_info->ready) {
       return;
     }
     bool erased =
-        Erase(&priority_infos_[stream_info.priority].ready_list, stream_info);
+        Erase(&priority_infos_[stream_info->priority].ready_list, stream_info);
     QUICHE_DCHECK(erased);
-    stream_info.ready = false;
+    stream_info->ready = false;
   }
 
   // Returns true iff the number of ready streams is non-zero.
@@ -279,7 +282,7 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
       QUICHE_DLOG(INFO) << "Stream " << stream_id << " not registered";
       return false;
     }
-    return it->second.ready;
+    return it->second->ready;
   }
 
  private:
@@ -304,12 +307,15 @@ class QUICHE_EXPORT_PRIVATE PriorityWriteScheduler
     int64_t last_event_time_usec = 0;
   };
 
-  typedef std::unordered_map<StreamIdType, StreamInfo> StreamInfoMap;
+  // Use std::unique_ptr, because absl::flat_hash_map does not have pointer
+  // stability, but ReadyList stores pointers to the StreamInfo objects.
+  using StreamInfoMap =
+      absl::flat_hash_map<StreamIdType, std::unique_ptr<StreamInfo>>;
 
   // Erases `info` from `ready_list`, returning true if found (and erased), or
   // false otherwise. Decrements `num_ready_streams_` if an entry is erased.
-  bool Erase(ReadyList* ready_list, const StreamInfo& info) {
-    auto it = std::remove(ready_list->begin(), ready_list->end(), &info);
+  bool Erase(ReadyList* ready_list, const StreamInfo* info) {
+    auto it = std::remove(ready_list->begin(), ready_list->end(), info);
     if (it == ready_list->end()) {
       // `info` was not found.
       return false;

package/third_party/quiche/quiche/http2/core/priority_write_scheduler_test.cc

@@ -4,8 +4,8 @@
 
 #include "quiche/http2/core/priority_write_scheduler.h"
 
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 #include "quiche/spdy/test_tools/spdy_test_utils.h"
 
@@ -35,7 +35,7 @@ class PriorityWriteSchedulerPeer {
 
 namespace {
 
-class PriorityWriteSchedulerTest : public QuicheTest {
+class PriorityWriteSchedulerTest : public quiche::test::QuicheTest {
  public:
   PriorityWriteSchedulerTest() : peer_(&scheduler_) {}
 

package/third_party/quiche/quiche/http2/decoder/decode_buffer_test.cc

@@ -43,7 +43,7 @@ struct TestStruct {
   TestEnum8 f8;
 };
 
-class DecodeBufferTest : public QuicheTest {
+class DecodeBufferTest : public quiche::test::QuicheTest {
  protected:
   Http2Random random_;
   uint32_t decode_offset_;
@@ -124,12 +124,12 @@ TEST_F(DecodeBufferTest, DecodeBufferSubsetAdvancesCursor) {
 // Make sure that DecodeBuffer ctor complains about bad args.
 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 TEST(DecodeBufferDeathTest, NonNullBufferRequired) {
-  EXPECT_DEBUG_DEATH({ DecodeBuffer b(nullptr, 3); }, "nullptr");
+  EXPECT_QUICHE_DEBUG_DEATH({ DecodeBuffer b(nullptr, 3); }, "nullptr");
 }
 
 // Make sure that DecodeBuffer ctor complains about bad args.
 TEST(DecodeBufferDeathTest, ModestBufferSizeRequired) {
-  EXPECT_DEBUG_DEATH(
+  EXPECT_QUICHE_DEBUG_DEATH(
       {
         // This depends on being able to allocate a fairly large array on the
         // stack. If that fails, we can instead do this:
@@ -152,7 +152,7 @@ TEST(DecodeBufferDeathTest, LimitedAdvance) {
     b.AdvanceCursor(3);  // OK
     EXPECT_TRUE(b.Empty());
   }
-  EXPECT_DEBUG_DEATH(
+  EXPECT_QUICHE_DEBUG_DEATH(
       {
         // Going beyond is not OK.
         const char data[] = "abc";
@@ -168,7 +168,7 @@ TEST(DecodeBufferDeathTest, DecodeUInt8PastEnd) {
   DecodeBuffer b(data, sizeof data);
   EXPECT_EQ(2u, b.FullSize());
   EXPECT_EQ(0x1223, b.DecodeUInt16());
-  EXPECT_DEBUG_DEATH({ b.DecodeUInt8(); }, "1 vs. 0");
+  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt8(); }, "1 vs. 0");
 }
 
 // Make sure that DecodeBuffer detects decode beyond end, in debug mode.
@@ -177,7 +177,7 @@ TEST(DecodeBufferDeathTest, DecodeUInt16OverEnd) {
   DecodeBuffer b(data, sizeof data);
   EXPECT_EQ(3u, b.FullSize());
   EXPECT_EQ(0x1223, b.DecodeUInt16());
-  EXPECT_DEBUG_DEATH({ b.DecodeUInt16(); }, "2 vs. 1");
+  EXPECT_QUICHE_DEBUG_DEATH({ b.DecodeUInt16(); }, "2 vs. 1");
 }
 
 // Make sure that DecodeBuffer doesn't agree with having two subsets.
@@ -185,8 +185,8 @@ TEST(DecodeBufferSubsetDeathTest, TwoSubsets) {
   const char data[] = "abc";
   DecodeBuffer base(data, 3);
   DecodeBufferSubset subset1(&base, 1);
-  EXPECT_DEBUG_DEATH({ DecodeBufferSubset subset2(&base, 1); },
-                     "There is already a subset");
+  EXPECT_QUICHE_DEBUG_DEATH({ DecodeBufferSubset subset2(&base, 1); },
+                            "There is already a subset");
 }
 
 // Make sure that DecodeBufferSubset notices when the base's cursor has moved.
@@ -194,7 +194,7 @@ TEST(DecodeBufferSubsetDeathTest, BaseCursorAdvanced) {
   const char data[] = "abc";
   DecodeBuffer base(data, 3);
   base.AdvanceCursor(1);
-  EXPECT_DEBUG_DEATH(
+  EXPECT_QUICHE_DEBUG_DEATH(
       {
         DecodeBufferSubset subset1(&base, 2);
         base.AdvanceCursor(1);

package/third_party/quiche/quiche/http2/decoder/decode_http2_structures_test.cc

@@ -39,7 +39,7 @@ std::string SerializeStructure(const S& s) {
 }
 
 template <class S>
-class StructureDecoderTest : public QuicheTest {
+class StructureDecoderTest : public quiche::test::QuicheTest {
  protected:
   typedef S Structure;
 

package/third_party/quiche/quiche/http2/decoder/http2_frame_decoder_test.cc

@@ -14,9 +14,9 @@
 #include "quiche/http2/test_tools/frame_parts.h"
 #include "quiche/http2/test_tools/frame_parts_collector_listener.h"
 #include "quiche/http2/test_tools/http2_random.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionSuccess;
 
@@ -93,8 +93,8 @@ class Http2FrameDecoderTest : public RandomDecoderTest {
   }
 
   AssertionResult VerifyCollected(const FrameParts& expected) {
-    VERIFY_FALSE(collector_.IsInProgress());
-    VERIFY_EQ(1u, collector_.size());
+    HTTP2_VERIFY_FALSE(collector_.IsInProgress());
+    HTTP2_VERIFY_EQ(1u, collector_.size());
     return expected.VerifyEquals(*collector_.frame(0));
   }
 
@@ -114,14 +114,14 @@ class Http2FrameDecoderTest : public RandomDecoderTest {
       absl::string_view payload, const FrameParts& expected) {
     auto validator = [&expected, this](const DecodeBuffer& /*input*/,
                                        DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeDone);
       return VerifyCollected(expected);
     };
     ResetDecodeSpeedCounters();
-    VERIFY_SUCCESS(DecodePayloadAndValidateSeveralWays(
+    HTTP2_VERIFY_SUCCESS(DecodePayloadAndValidateSeveralWays(
         payload, ValidateDoneAndEmpty(validator)));
-    VERIFY_GT(fast_decode_count_, 0u);
-    VERIFY_GT(slow_decode_count_, 0u);
+    HTTP2_VERIFY_GT(fast_decode_count_, 0u);
+    HTTP2_VERIFY_GT(slow_decode_count_, 0u);
 
     // Repeat with more input; it should stop without reading that input.
     std::string next_frame = Random().RandString(10);
@@ -129,10 +129,10 @@ class Http2FrameDecoderTest : public RandomDecoderTest {
     input += next_frame;
 
     ResetDecodeSpeedCounters();
-    VERIFY_SUCCESS(DecodePayloadAndValidateSeveralWays(
+    HTTP2_VERIFY_SUCCESS(DecodePayloadAndValidateSeveralWays(
         payload, ValidateDoneAndOffset(payload.size(), validator)));
-    VERIFY_GT(fast_decode_count_, 0u);
-    VERIFY_GT(slow_decode_count_, 0u);
+    HTTP2_VERIFY_GT(fast_decode_count_, 0u);
+    HTTP2_VERIFY_GT(slow_decode_count_, 0u);
 
     return AssertionSuccess();
   }
@@ -156,7 +156,7 @@ class Http2FrameDecoderTest : public RandomDecoderTest {
                                               const FrameParts& expected) {
     auto validator = [&expected, this](const DecodeBuffer& /*input*/,
                                        DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(status, DecodeStatus::kDecodeError);
+      HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeError);
       return VerifyCollected(expected);
     };
     ResetDecodeSpeedCounters();
@@ -834,10 +834,10 @@ TEST_F(Http2FrameDecoderTest, BeyondMaximum) {
   expected.SetHasFrameSizeError(true);
   auto validator = [&expected, this](const DecodeBuffer& input,
                                      DecodeStatus status) -> AssertionResult {
-    VERIFY_EQ(status, DecodeStatus::kDecodeError);
+    HTTP2_VERIFY_EQ(status, DecodeStatus::kDecodeError);
     // The decoder detects this error after decoding the header, and without
     // trying to decode the payload.
-    VERIFY_EQ(input.Offset(), Http2FrameHeader::EncodedSize());
+    HTTP2_VERIFY_EQ(input.Offset(), Http2FrameHeader::EncodedSize());
     return VerifyCollected(expected);
   };
   ResetDecodeSpeedCounters();

package/third_party/quiche/quiche/http2/decoder/http2_structure_decoder_test.cc

@@ -29,9 +29,9 @@
 #include "quiche/http2/http2_constants.h"
 #include "quiche/http2/test_tools/http2_frame_builder.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionSuccess;
 
@@ -92,7 +92,7 @@ class Http2StructureDecoderTest : public RandomDecoderTest {
   // *expected (if provided).
   AssertionResult DecodeLeadingStructure(const S* expected,
                                          absl::string_view data) {
-    VERIFY_LE(S::EncodedSize(), data.size());
+    HTTP2_VERIFY_LE(S::EncodedSize(), data.size());
     DecodeBuffer original(data);
 
     // The validator is called after each of the several times that the input
@@ -102,7 +102,7 @@ class Http2StructureDecoderTest : public RandomDecoderTest {
     if (expected != nullptr) {
       validator = [expected, this](const DecodeBuffer& /*db*/,
                                    DecodeStatus /*status*/) -> AssertionResult {
-        VERIFY_EQ(*expected, *structure_);
+        HTTP2_VERIFY_EQ(*expected, *structure_);
         return AssertionSuccess();
       };
     }
@@ -116,26 +116,26 @@ class Http2StructureDecoderTest : public RandomDecoderTest {
     slow_decode_count_ = 0;
     incomplete_start_count_ = 0;
     incomplete_resume_count_ = 0;
-    VERIFY_SUCCESS(DecodeAndValidateSeveralWays(
+    HTTP2_VERIFY_SUCCESS(DecodeAndValidateSeveralWays(
         &original, kMayReturnZeroOnFirst, validator));
-    VERIFY_FALSE(HasFailure());
-    VERIFY_EQ(S::EncodedSize(), structure_decoder_.offset());
-    VERIFY_EQ(S::EncodedSize(), original.Offset());
-    VERIFY_LT(0u, fast_decode_count_);
-    VERIFY_LT(0u, slow_decode_count_);
-    VERIFY_LT(0u, incomplete_start_count_);
+    HTTP2_VERIFY_FALSE(HasFailure());
+    HTTP2_VERIFY_EQ(S::EncodedSize(), structure_decoder_.offset());
+    HTTP2_VERIFY_EQ(S::EncodedSize(), original.Offset());
+    HTTP2_VERIFY_LT(0u, fast_decode_count_);
+    HTTP2_VERIFY_LT(0u, slow_decode_count_);
+    HTTP2_VERIFY_LT(0u, incomplete_start_count_);
 
     // If the structure is large enough so that SelectZeroOrOne will have
     // caused Resume to return false, check that occurred.
     if (S::EncodedSize() >= 2) {
-      VERIFY_LE(0u, incomplete_resume_count_);
+      HTTP2_VERIFY_LE(0u, incomplete_resume_count_);
     } else {
-      VERIFY_EQ(0u, incomplete_resume_count_);
+      HTTP2_VERIFY_EQ(0u, incomplete_resume_count_);
     }
     if (expected != nullptr) {
       QUICHE_DVLOG(1) << "DecodeLeadingStructure expected: " << *expected;
       QUICHE_DVLOG(1) << "DecodeLeadingStructure   actual: " << *structure_;
-      VERIFY_EQ(*expected, *structure_);
+      HTTP2_VERIFY_EQ(*expected, *structure_);
     }
     return AssertionSuccess();
   }
@@ -154,7 +154,7 @@ class Http2StructureDecoderTest : public RandomDecoderTest {
   // and validate that the decoder produced the same field values.
   AssertionResult EncodeThenDecode(const S& in_s) {
     std::string bytes = SerializeStructure(in_s);
-    VERIFY_EQ(S::EncodedSize(), bytes.size());
+    HTTP2_VERIFY_EQ(S::EncodedSize(), bytes.size());
     return DecodeLeadingStructure(&in_s, bytes);
   }
 
@@ -165,13 +165,13 @@ class Http2StructureDecoderTest : public RandomDecoderTest {
     for (size_t i = 0; i < count; ++i) {
       Structure input;
       Randomize(&input, RandomPtr());
-      VERIFY_SUCCESS(EncodeThenDecode(input));
+      HTTP2_VERIFY_SUCCESS(EncodeThenDecode(input));
     }
     return AssertionSuccess();
   }
 
   AssertionResult TestDecodingRandomizedStructures() {
-    VERIFY_SUCCESS(TestDecodingRandomizedStructures(100));
+    HTTP2_VERIFY_SUCCESS(TestDecodingRandomizedStructures(100));
     return AssertionSuccess();
   }
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder_test.cc

@@ -17,7 +17,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/continuation_payload_decoder_test.cc

@@ -15,7 +15,7 @@
 #include "quiche/http2/test_tools/frame_parts.h"
 #include "quiche/http2/test_tools/frame_parts_collector.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/data_payload_decoder_test.cc

@@ -17,10 +17,10 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {

package/third_party/quiche/quiche/http2/decoder/payload_decoders/goaway_payload_decoder_test.cc

@@ -16,7 +16,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/headers_payload_decoder_test.cc

@@ -16,7 +16,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/ping_payload_decoder_test.cc

@@ -14,7 +14,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/priority_payload_decoder_test.cc

@@ -14,7 +14,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder_test.cc

@@ -16,7 +16,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder_test.cc

@@ -16,7 +16,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder_test.cc

@@ -15,7 +15,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/settings_payload_decoder_test.cc

@@ -17,7 +17,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"