Moves EXPECT_SPDY_BUG into Quiche as EXPECT_QUICHE_BUG.

There are no Chromium references to EXPECT_SPDY_BUG outside of the code imported from Quiche and the one line platform implementation.
  https://source.chromium.org/chromium/chromium/src/+/master:net/spdy/platform/impl/spdy_test_helpers_impl.h

PiperOrigin-RevId: 368737375
Change-Id: If1ae8022d694b2a28e33a2a48ccadd54b9b93f4f
diff --git a/common/platform/api/quiche_test_helpers.h b/common/platform/api/quiche_test_helpers.h
new file mode 100644
index 0000000..8e773a1
--- /dev/null
+++ b/common/platform/api/quiche_test_helpers.h
@@ -0,0 +1,8 @@
+#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_
+#define QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_
+
+#include "net/quiche/common/platform/impl/quiche_test_helpers_impl.h"
+
+#define EXPECT_QUICHE_BUG EXPECT_QUICHE_BUG_IMPL
+
+#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_
diff --git a/http2/adapter/oghttp2_adapter_test.cc b/http2/adapter/oghttp2_adapter_test.cc
index 436fb2e..fef15aa 100644
--- a/http2/adapter/oghttp2_adapter_test.cc
+++ b/http2/adapter/oghttp2_adapter_test.cc
@@ -3,7 +3,7 @@
 #include "http2/adapter/mock_http2_visitor.h"
 #include "http2/adapter/test_utils.h"
 #include "common/platform/api/quiche_test.h"
-#include "spdy/platform/api/spdy_test_helpers.h"
+#include "common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace adapter {
@@ -22,23 +22,23 @@
 };
 
 TEST_F(OgHttp2AdapterTest, ProcessBytes) {
-  EXPECT_SPDY_BUG(adapter_->ProcessBytes("fake data"), "Not implemented");
+  EXPECT_QUICHE_BUG(adapter_->ProcessBytes("fake data"), "Not implemented");
 }
 
 TEST_F(OgHttp2AdapterTest, SubmitMetadata) {
-  EXPECT_SPDY_BUG(adapter_->SubmitMetadata(3, true), "Not implemented");
+  EXPECT_QUICHE_BUG(adapter_->SubmitMetadata(3, true), "Not implemented");
 }
 
 TEST_F(OgHttp2AdapterTest, GetPeerConnectionWindow) {
   int peer_window = 0;
-  EXPECT_SPDY_BUG(peer_window = adapter_->GetPeerConnectionWindow(),
-                  "Not implemented");
+  EXPECT_QUICHE_BUG(peer_window = adapter_->GetPeerConnectionWindow(),
+                    "Not implemented");
   EXPECT_GT(peer_window, 0);
 }
 
 TEST_F(OgHttp2AdapterTest, MarkDataConsumedForStream) {
-  EXPECT_SPDY_BUG(adapter_->MarkDataConsumedForStream(1, 11),
-                  "Stream 1 not found");
+  EXPECT_QUICHE_BUG(adapter_->MarkDataConsumedForStream(1, 11),
+                    "Stream 1 not found");
 }
 
 TEST_F(OgHttp2AdapterTest, TestSerialize) {
diff --git a/http2/adapter/window_manager_test.cc b/http2/adapter/window_manager_test.cc
index 549fd1c..5e06453 100644
--- a/http2/adapter/window_manager_test.cc
+++ b/http2/adapter/window_manager_test.cc
@@ -5,7 +5,7 @@
 #include "absl/functional/bind_front.h"
 #include "http2/test_tools/http2_random.h"
 #include "common/platform/api/quiche_test.h"
-#include "spdy/platform/api/spdy_test_helpers.h"
+#include "common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace adapter {
@@ -97,13 +97,13 @@
 TEST_F(WindowManagerTest, AvoidBufferedUnderflow) {
   EXPECT_EQ(peer_.buffered(), 0);
   // Don't flush more than has been buffered!
-  EXPECT_SPDY_BUG(wm_.MarkDataFlushed(1), "buffered underflow");
+  EXPECT_QUICHE_BUG(wm_.MarkDataFlushed(1), "buffered underflow");
   EXPECT_EQ(peer_.buffered(), 0);
 
   wm_.MarkDataBuffered(42);
   EXPECT_EQ(peer_.buffered(), 42);
   // Don't flush more than has been buffered!
-  EXPECT_SPDY_BUG(wm_.MarkDataFlushed(43), "buffered underflow");
+  EXPECT_QUICHE_BUG(wm_.MarkDataFlushed(43), "buffered underflow");
   EXPECT_EQ(peer_.buffered(), 0);
 }
 
diff --git a/http2/core/http2_priority_write_scheduler_test.cc b/http2/core/http2_priority_write_scheduler_test.cc
index 5c97766..7f08619 100644
--- a/http2/core/http2_priority_write_scheduler_test.cc
+++ b/http2/core/http2_priority_write_scheduler_test.cc
@@ -7,7 +7,7 @@
 #include <initializer_list>
 
 #include "common/platform/api/quiche_test.h"
-#include "spdy/platform/api/spdy_test_helpers.h"
+#include "common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
@@ -68,7 +68,7 @@
 
   scheduler_.RegisterStream(5, SpdyStreamPrecedence(0, 50, false));
   // Should not be able to add a stream with an id that already exists.
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.RegisterStream(5, SpdyStreamPrecedence(1, 50, false)),
       "Stream 5 already registered");
   EXPECT_EQ(3u, scheduler_.NumRegisteredStreams());
@@ -87,7 +87,7 @@
 
   scheduler_.UnregisterStream(5);
   // Cannot remove a stream that has already been removed.
-  EXPECT_SPDY_BUG(scheduler_.UnregisterStream(5), "Stream 5 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.UnregisterStream(5), "Stream 5 not registered");
   EXPECT_EQ(3u, scheduler_.NumRegisteredStreams());
   EXPECT_TRUE(scheduler_.StreamRegistered(1));
   EXPECT_FALSE(scheduler_.StreamRegistered(5));
@@ -99,7 +99,7 @@
   EXPECT_TRUE(scheduler_.StreamRegistered(7));
   EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(7).parent_id());
   // Now stream 7 already exists, so this should fail:
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.RegisterStream(7, SpdyStreamPrecedence(1, 70, false)),
       "Stream 7 already registered");
   // Try adding a second child to stream 13:
@@ -121,8 +121,8 @@
   EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(1).parent_id());
   EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty());
 
-  EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
-                  "Stream 1 already registered");
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
+                    "Stream 1 already registered");
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
 }
 
@@ -161,20 +161,20 @@
 }
 
 TEST_F(Http2PriorityWriteSchedulerTest, GetStreamChildren) {
-  EXPECT_SPDY_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()),
-                  "Stream 7 not registered");
+  EXPECT_QUICHE_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()),
+                    "Stream 7 not registered");
   scheduler_.RegisterStream(7, SpdyStreamPrecedence(0, 70, false));
   EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty());
   scheduler_.RegisterStream(9, SpdyStreamPrecedence(7, 90, false));
   scheduler_.RegisterStream(15, SpdyStreamPrecedence(7, 150, false));
   EXPECT_THAT(scheduler_.GetStreamChildren(7), UnorderedElementsAre(9, 15));
   scheduler_.UnregisterStream(7);
-  EXPECT_SPDY_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()),
-                  "Stream 7 not registered");
+  EXPECT_QUICHE_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()),
+                    "Stream 7 not registered");
 }
 
 TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamWeight) {
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.UpdateStreamPrecedence(0, SpdyStreamPrecedence(0, 10, false)),
       "Cannot set precedence of root stream");
 
@@ -189,11 +189,11 @@
   EXPECT_EQ(20, scheduler_.GetStreamPrecedence(3).weight());
   ASSERT_TRUE(peer_.ValidateInvariants());
 
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 500, false)),
       "Invalid weight: 500");
   EXPECT_EQ(kHttp2MaxStreamWeight, scheduler_.GetStreamPrecedence(3).weight());
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 0, false)),
       "Invalid weight: 0");
   EXPECT_EQ(kHttp2MinStreamWeight, scheduler_.GetStreamPrecedence(3).weight());
@@ -574,10 +574,10 @@
 
 TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentToSelf) {
   scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false));
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(1, 100, false)),
       "Cannot set stream to be its own parent");
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(1, 100, true)),
       "Cannot set stream to be its own parent");
   EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1));
@@ -666,7 +666,7 @@
   scheduler_.UnregisterStream(1);
   EXPECT_FALSE(scheduler_.HasReadyStreams());
   ASSERT_TRUE(peer_.ValidateInvariants());
-  EXPECT_SPDY_BUG(scheduler_.IsStreamReady(1), "Stream 1 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.IsStreamReady(1), "Stream 1 not registered");
 }
 
 TEST_F(Http2PriorityWriteSchedulerTest, CalculateRoundedWeights) {
@@ -704,10 +704,10 @@
 }
 
 TEST_F(Http2PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) {
-  EXPECT_SPDY_BUG(scheduler_.RecordStreamEventTime(3, 5),
-                  "Stream 3 not registered");
-  EXPECT_SPDY_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)),
-                  "Stream 4 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.RecordStreamEventTime(3, 5),
+                    "Stream 3 not registered");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)),
+                    "Stream 4 not registered");
 
   for (int i = 1; i < 5; ++i) {
     int weight = SpdyStreamPrecedence(i).weight();
diff --git a/http2/core/priority_write_scheduler_test.cc b/http2/core/priority_write_scheduler_test.cc
index bf6edc8..e4e6997 100644
--- a/http2/core/priority_write_scheduler_test.cc
+++ b/http2/core/priority_write_scheduler_test.cc
@@ -5,9 +5,9 @@
 #include "http2/core/priority_write_scheduler.h"
 
 #include "common/platform/api/quiche_test.h"
+#include "common/platform/api/quiche_test_helpers.h"
 #include "spdy/core/spdy_protocol.h"
 #include "spdy/core/spdy_test_utils.h"
-#include "spdy/platform/api/spdy_test_helpers.h"
 
 namespace http2 {
 namespace test {
@@ -52,15 +52,15 @@
   EXPECT_EQ(1u, scheduler_.NumRegisteredStreams());
 
   // Root stream counts as already registered.
-  EXPECT_SPDY_BUG(
+  EXPECT_QUICHE_BUG(
       scheduler_.RegisterStream(kHttp2RootStreamId, SpdyStreamPrecedence(1)),
       "Stream 0 already registered");
 
   // Try redundant registrations.
-  EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)),
-                  "Stream 1 already registered");
-  EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(2)),
-                  "Stream 1 already registered");
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)),
+                    "Stream 1 already registered");
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(2)),
+                    "Stream 1 already registered");
 
   scheduler_.RegisterStream(2, SpdyStreamPrecedence(3));
   EXPECT_EQ(2u, scheduler_.NumRegisteredStreams());
@@ -74,8 +74,8 @@
   EXPECT_EQ(0u, scheduler_.NumRegisteredStreams());
 
   // Try redundant unregistration.
-  EXPECT_SPDY_BUG(scheduler_.UnregisterStream(1), "Stream 1 not registered");
-  EXPECT_SPDY_BUG(scheduler_.UnregisterStream(2), "Stream 2 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.UnregisterStream(1), "Stream 1 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.UnregisterStream(2), "Stream 2 not registered");
 }
 
 TEST_F(PriorityWriteSchedulerTest, RegisterStreamWithHttp2StreamDependency) {
@@ -88,9 +88,10 @@
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
   EXPECT_FALSE(scheduler_.HasReadyStreams());
 
-  EXPECT_SPDY_BUG(scheduler_.RegisterStream(
-                      1, SpdyStreamPrecedence(kHttp2RootStreamId, 256, false)),
-                  "Stream 1 already registered");
+  EXPECT_QUICHE_BUG(
+      scheduler_.RegisterStream(
+          1, SpdyStreamPrecedence(kHttp2RootStreamId, 256, false)),
+      "Stream 1 already registered");
   EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority());
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
 
@@ -113,8 +114,8 @@
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
 
   // Redundant registration shouldn't change stream priority.
-  EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
-                  "Stream 1 already registered");
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
+                    "Stream 1 already registered");
   EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
 
   scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(5));
@@ -210,11 +211,11 @@
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBack) {
   EXPECT_FALSE(scheduler_.HasReadyStreams());
-  EXPECT_SPDY_BUG(scheduler_.MarkStreamReady(1, false),
-                  "Stream 1 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.MarkStreamReady(1, false),
+                    "Stream 1 not registered");
   EXPECT_FALSE(scheduler_.HasReadyStreams());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 
   // Add a bunch of ready streams to tail of per-priority lists.
   // Expected order: (P2) 4, (P3) 1, 2, 3, (P5) 5.
@@ -235,17 +236,17 @@
   EXPECT_EQ(2u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(3u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(5u, scheduler_.PopNextReadyStream());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 }
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyFront) {
   EXPECT_FALSE(scheduler_.HasReadyStreams());
-  EXPECT_SPDY_BUG(scheduler_.MarkStreamReady(1, true),
-                  "Stream 1 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.MarkStreamReady(1, true),
+                    "Stream 1 not registered");
   EXPECT_FALSE(scheduler_.HasReadyStreams());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 
   // Add a bunch of ready streams to head of per-priority lists.
   // Expected order: (P2) 4, (P3) 3, 2, 1, (P5) 5
@@ -266,8 +267,8 @@
   EXPECT_EQ(2u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(1u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(5u, scheduler_.PopNextReadyStream());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 }
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBackAndFront) {
@@ -294,8 +295,8 @@
   EXPECT_EQ(3u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(1u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(5u, scheduler_.PopNextReadyStream());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 }
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamNotReady) {
@@ -308,15 +309,16 @@
   EXPECT_EQ(0u, scheduler_.NumReadyStreams());
 
   // Empty pop should fail.
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 
   // Tolerate redundant marking of a stream as not ready.
   scheduler_.MarkStreamNotReady(1);
   EXPECT_EQ(0u, scheduler_.NumReadyStreams());
 
   // Should only be able to mark registered streams.
-  EXPECT_SPDY_BUG(scheduler_.MarkStreamNotReady(3), "Stream 3 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.MarkStreamNotReady(3),
+                    "Stream 3 not registered");
 }
 
 TEST_F(PriorityWriteSchedulerTest, UnregisterRemovesStream) {
@@ -327,8 +329,8 @@
   // Unregistering a stream should remove it from set of ready streams.
   scheduler_.UnregisterStream(3);
   EXPECT_EQ(0u, scheduler_.NumReadyStreams());
-  EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
-                  "No ready streams available");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()),
+                    "No ready streams available");
 }
 
 TEST_F(PriorityWriteSchedulerTest, ShouldYield) {
@@ -359,10 +361,10 @@
 }
 
 TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) {
-  EXPECT_SPDY_BUG(scheduler_.RecordStreamEventTime(3, 5),
-                  "Stream 3 not registered");
-  EXPECT_SPDY_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)),
-                  "Stream 4 not registered");
+  EXPECT_QUICHE_BUG(scheduler_.RecordStreamEventTime(3, 5),
+                    "Stream 3 not registered");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)),
+                    "Stream 4 not registered");
 
   for (int i = 1; i < 5; ++i) {
     scheduler_.RegisterStream(i, SpdyStreamPrecedence(i));
diff --git a/spdy/core/spdy_protocol_test.cc b/spdy/core/spdy_protocol_test.cc
index 966c471..dbea0e3 100644
--- a/spdy/core/spdy_protocol_test.cc
+++ b/spdy/core/spdy_protocol_test.cc
@@ -9,9 +9,9 @@
 #include <memory>
 
 #include "common/platform/api/quiche_test.h"
+#include "common/platform/api/quiche_test_helpers.h"
 #include "spdy/core/spdy_bitmasks.h"
 #include "spdy/core/spdy_test_utils.h"
-#include "spdy/platform/api/spdy_test_helpers.h"
 
 namespace spdy {
 
@@ -31,16 +31,16 @@
 namespace test {
 
 TEST(SpdyProtocolTest, ClampSpdy3Priority) {
-  EXPECT_SPDY_BUG(EXPECT_EQ(7, ClampSpdy3Priority(8)), "Invalid priority: 8");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(7, ClampSpdy3Priority(8)), "Invalid priority: 8");
   EXPECT_EQ(kV3LowestPriority, ClampSpdy3Priority(kV3LowestPriority));
   EXPECT_EQ(kV3HighestPriority, ClampSpdy3Priority(kV3HighestPriority));
 }
 
 TEST(SpdyProtocolTest, ClampHttp2Weight) {
-  EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(0)),
-                  "Invalid weight: 0");
-  EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(300)),
-                  "Invalid weight: 300");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(0)),
+                    "Invalid weight: 0");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(300)),
+                    "Invalid weight: 300");
   EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(kHttp2MinStreamWeight));
   EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(kHttp2MaxStreamWeight));
 }
@@ -175,14 +175,14 @@
 }
 
 TEST(SpdyStreamPrecedenceTest, Clamping) {
-  EXPECT_SPDY_BUG(EXPECT_EQ(7, SpdyStreamPrecedence(8).spdy3_priority()),
-                  "Invalid priority: 8");
-  EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MinStreamWeight,
-                            SpdyStreamPrecedence(3, 0, false).weight()),
-                  "Invalid weight: 0");
-  EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MaxStreamWeight,
-                            SpdyStreamPrecedence(3, 300, false).weight()),
-                  "Invalid weight: 300");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(7, SpdyStreamPrecedence(8).spdy3_priority()),
+                    "Invalid priority: 8");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight,
+                              SpdyStreamPrecedence(3, 0, false).weight()),
+                    "Invalid weight: 0");
+  EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight,
+                              SpdyStreamPrecedence(3, 300, false).weight()),
+                    "Invalid weight: 300");
 }
 
 TEST(SpdyStreamPrecedenceTest, Copying) {
diff --git a/spdy/platform/api/spdy_test_helpers.h b/spdy/platform/api/spdy_test_helpers.h
deleted file mode 100644
index 367d330..0000000
--- a/spdy/platform/api/spdy_test_helpers.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-#ifndef QUICHE_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_
-#define QUICHE_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_
-
-#include "net/spdy/platform/impl/spdy_test_helpers_impl.h"
-
-#define EXPECT_SPDY_BUG EXPECT_SPDY_BUG_IMPL
-
-#endif  // QUICHE_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_