diff --git a/quic/core/batch_writer/quic_batch_writer_base.cc b/quic/core/batch_writer/quic_batch_writer_base.cc
index b1cd520..b2fd80c 100644
--- a/quic/core/batch_writer/quic_batch_writer_base.cc
+++ b/quic/core/batch_writer/quic_batch_writer_base.cc
@@ -141,12 +141,12 @@
 
   // Either flush_result.write_result.status is not WRITE_STATUS_OK, or it is
   // WRITE_STATUS_OK and batch_buffer is empty.
-  DCHECK(flush_result.write_result.status != WRITE_STATUS_OK ||
-         buffered_writes().empty());
+  QUICHE_DCHECK(flush_result.write_result.status != WRITE_STATUS_OK ||
+                buffered_writes().empty());
 
   // Flush should never return WRITE_STATUS_BLOCKED_DATA_BUFFERED.
-  DCHECK(flush_result.write_result.status !=
-         WRITE_STATUS_BLOCKED_DATA_BUFFERED);
+  QUICHE_DCHECK(flush_result.write_result.status !=
+                WRITE_STATUS_BLOCKED_DATA_BUFFERED);
 
   return flush_result;
 }
diff --git a/quic/core/batch_writer/quic_batch_writer_buffer.cc b/quic/core/batch_writer/quic_batch_writer_buffer.cc
index 7e30179..0de792d 100644
--- a/quic/core/batch_writer/quic_batch_writer_buffer.cc
+++ b/quic/core/batch_writer/quic_batch_writer_buffer.cc
@@ -60,8 +60,8 @@
     const QuicSocketAddress& peer_address,
     const PerPacketOptions* options,
     uint64_t release_time) {
-  DCHECK(Invariants());
-  DCHECK_LE(buf_len, kMaxOutgoingPacketSize);
+  QUICHE_DCHECK(Invariants());
+  QUICHE_DCHECK_LE(buf_len, kMaxOutgoingPacketSize);
 
   PushResult result = {/*succeeded=*/false, /*buffer_copied=*/false};
   char* next_write_location = GetNextWriteLocation();
@@ -91,7 +91,7 @@
       options ? options->Clone() : std::unique_ptr<PerPacketOptions>(),
       release_time);
 
-  DCHECK(Invariants());
+  QUICHE_DCHECK(Invariants());
 
   result.succeeded = true;
   return result;
@@ -105,9 +105,10 @@
 
 QuicBatchWriterBuffer::PopResult QuicBatchWriterBuffer::PopBufferedWrite(
     int32_t num_buffered_writes) {
-  DCHECK(Invariants());
-  DCHECK_GE(num_buffered_writes, 0);
-  DCHECK_LE(static_cast<size_t>(num_buffered_writes), buffered_writes_.size());
+  QUICHE_DCHECK(Invariants());
+  QUICHE_DCHECK_GE(num_buffered_writes, 0);
+  QUICHE_DCHECK_LE(static_cast<size_t>(num_buffered_writes),
+                   buffered_writes_.size());
 
   PopResult result = {/*num_buffers_popped=*/0,
                       /*moved_remaining_buffers=*/false};
@@ -135,9 +136,9 @@
       buffered_write.buffer -= distance_to_move;
     }
 
-    DCHECK_EQ(buffer_, buffered_writes_.front().buffer);
+    QUICHE_DCHECK_EQ(buffer_, buffered_writes_.front().buffer);
   }
-  DCHECK(Invariants());
+  QUICHE_DCHECK(Invariants());
 
   return result;
 }
diff --git a/quic/core/batch_writer/quic_gso_batch_writer.cc b/quic/core/batch_writer/quic_gso_batch_writer.cc
index 564fd84..fa26516 100644
--- a/quic/core/batch_writer/quic_gso_batch_writer.cc
+++ b/quic/core/batch_writer/quic_gso_batch_writer.cc
@@ -101,7 +101,7 @@
 
 QuicGsoBatchWriter::ReleaseTime QuicGsoBatchWriter::GetReleaseTime(
     const PerPacketOptions* options) const {
-  DCHECK(SupportsReleaseTime());
+  QUICHE_DCHECK(SupportsReleaseTime());
 
   if (options == nullptr) {
     return {0, QuicTime::Delta::Zero()};
diff --git a/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc b/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
index eacb611..ec8e4ae 100644
--- a/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
+++ b/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
@@ -32,8 +32,8 @@
 QuicSendmmsgBatchWriter::FlushImplResult
 QuicSendmmsgBatchWriter::InternalFlushImpl(size_t cmsg_space,
                                            const CmsgBuilder& cmsg_builder) {
-  DCHECK(!IsWriteBlocked());
-  DCHECK(!buffered_writes().empty());
+  QUICHE_DCHECK(!IsWriteBlocked());
+  QUICHE_DCHECK(!buffered_writes().empty());
 
   FlushImplResult result = {WriteResult(WRITE_STATUS_OK, 0),
                             /*num_packets_sent=*/0, /*bytes_written=*/0};
@@ -52,7 +52,7 @@
                   << " packets. WriteResult=" << write_result;
 
     if (write_result.status != WRITE_STATUS_OK) {
-      DCHECK_EQ(0, num_packets_sent);
+      QUICHE_DCHECK_EQ(0, num_packets_sent);
       break;
     } else if (num_packets_sent == 0) {
       QUIC_BUG << "WriteMultiplePackets returned OK, but no packets were sent.";
diff --git a/quic/core/congestion_control/bbr2_drain.cc b/quic/core/congestion_control/bbr2_drain.cc
index 97fa576..69befb5 100644
--- a/quic/core/congestion_control/bbr2_drain.cc
+++ b/quic/core/congestion_control/bbr2_drain.cc
@@ -18,7 +18,7 @@
   model_->set_pacing_gain(Params().drain_pacing_gain);
 
   // Only STARTUP can transition to DRAIN, both of them use the same cwnd gain.
-  DCHECK_EQ(model_->cwnd_gain(), Params().drain_cwnd_gain);
+  QUICHE_DCHECK_EQ(model_->cwnd_gain(), Params().drain_cwnd_gain);
   model_->set_cwnd_gain(Params().drain_cwnd_gain);
 
   QuicByteCount drain_target = DrainTarget();
diff --git a/quic/core/congestion_control/bbr2_misc.cc b/quic/core/congestion_control/bbr2_misc.cc
index 4413ba3..dfb834c 100644
--- a/quic/core/congestion_control/bbr2_misc.cc
+++ b/quic/core/congestion_control/bbr2_misc.cc
@@ -16,8 +16,8 @@
 RoundTripCounter::RoundTripCounter() : round_trip_count_(0) {}
 
 void RoundTripCounter::OnPacketSent(QuicPacketNumber packet_number) {
-  DCHECK(!last_sent_packet_.IsInitialized() ||
-         last_sent_packet_ < packet_number);
+  QUICHE_DCHECK(!last_sent_packet_.IsInitialized() ||
+                last_sent_packet_ < packet_number);
   last_sent_packet_ = packet_number;
 }
 
@@ -188,7 +188,7 @@
 void Bbr2NetworkModel::AdaptLowerBounds(
     const Bbr2CongestionEvent& congestion_event) {
   if (Params().bw_lo_mode_ != Bbr2Params::DEFAULT) {
-    DCHECK(Params().bw_startup);
+    QUICHE_DCHECK(Params().bw_startup);
     if (congestion_event.bytes_lost == 0) {
       return;
     }
@@ -366,7 +366,7 @@
 }
 
 void Bbr2NetworkModel::OnNewRound() {
-  DCHECK(reset_max_bytes_delivered_);
+  QUICHE_DCHECK(reset_max_bytes_delivered_);
   bytes_lost_in_round_ = 0;
   loss_events_in_round_ = 0;
   max_bytes_delivered_in_round_ = 0;
@@ -389,8 +389,8 @@
 
 Bbr2NetworkModel::BandwidthGrowth Bbr2NetworkModel::CheckBandwidthGrowth(
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK(!full_bandwidth_reached_);
-  DCHECK(congestion_event.end_of_round_trip);
+  QUICHE_DCHECK(!full_bandwidth_reached_);
+  QUICHE_DCHECK(congestion_event.end_of_round_trip);
   if (congestion_event.last_sample_is_app_limited) {
     return APP_LIMITED;
   }
diff --git a/quic/core/congestion_control/bbr2_probe_bw.cc b/quic/core/congestion_control/bbr2_probe_bw.cc
index 031e5a1..78bd06d 100644
--- a/quic/core/congestion_control/bbr2_probe_bw.cc
+++ b/quic/core/congestion_control/bbr2_probe_bw.cc
@@ -24,8 +24,8 @@
   } else {
     // Transitioning from PROBE_RTT to PROBE_BW. Re-enter the last phase before
     // PROBE_RTT.
-    DCHECK(cycle_.phase == CyclePhase::PROBE_CRUISE ||
-           cycle_.phase == CyclePhase::PROBE_REFILL);
+    QUICHE_DCHECK(cycle_.phase == CyclePhase::PROBE_CRUISE ||
+                  cycle_.phase == CyclePhase::PROBE_REFILL);
     cycle_.cycle_start_time = now;
     if (cycle_.phase == CyclePhase::PROBE_CRUISE) {
       EnterProbeCruise(now);
@@ -41,7 +41,7 @@
     const AckedPacketVector& /*acked_packets*/,
     const LostPacketVector& /*lost_packets*/,
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_NE(cycle_.phase, CyclePhase::PROBE_NOT_STARTED);
+  QUICHE_DCHECK_NE(cycle_.phase, CyclePhase::PROBE_NOT_STARTED);
 
   if (congestion_event.end_of_round_trip) {
     if (cycle_.cycle_start_time != event_time) {
@@ -130,7 +130,7 @@
 void Bbr2ProbeBwMode::UpdateProbeDown(
     QuicByteCount prior_in_flight,
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
 
   if (cycle_.rounds_in_phase == 1 && congestion_event.end_of_round_trip) {
     cycle_.is_sample_from_probing = false;
@@ -346,7 +346,7 @@
 }
 
 void Bbr2ProbeBwMode::RaiseInflightHighSlope() {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
   uint64_t growth_this_round = 1 << cycle_.probe_up_rounds;
   // The number 30 below means |growth_this_round| is capped at 1G and the lower
   // bound of |probe_up_bytes| is (practically) 1 mss, at this speed inflight_hi
@@ -362,7 +362,7 @@
 
 void Bbr2ProbeBwMode::ProbeInflightHighUpward(
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
   if (!model_->IsCongestionWindowLimited(congestion_event)) {
     QUIC_DVLOG(3) << sender_
                   << " Raising inflight_hi early return: Not cwnd limited.";
@@ -406,9 +406,9 @@
 
 void Bbr2ProbeBwMode::UpdateProbeCruise(
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_CRUISE);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_CRUISE);
   MaybeAdaptUpperBounds(congestion_event);
-  DCHECK(!cycle_.is_sample_from_probing);
+  QUICHE_DCHECK(!cycle_.is_sample_from_probing);
 
   if (IsTimeToProbeBandwidth(congestion_event)) {
     EnterProbeRefill(/*probe_up_rounds=*/0, congestion_event.event_time);
@@ -418,9 +418,9 @@
 
 void Bbr2ProbeBwMode::UpdateProbeRefill(
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
   MaybeAdaptUpperBounds(congestion_event);
-  DCHECK(!cycle_.is_sample_from_probing);
+  QUICHE_DCHECK(!cycle_.is_sample_from_probing);
 
   if (cycle_.rounds_in_phase > 0 && congestion_event.end_of_round_trip) {
     EnterProbeUp(congestion_event.event_time);
@@ -431,7 +431,7 @@
 void Bbr2ProbeBwMode::UpdateProbeUp(
     QuicByteCount prior_in_flight,
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
   if (MaybeAdaptUpperBounds(congestion_event) == ADAPTED_PROBED_TOO_HIGH) {
     EnterProbeDown(/*probed_too_high=*/true, /*stopped_risky_probe=*/false,
                    congestion_event.event_time);
@@ -553,7 +553,7 @@
 }
 
 void Bbr2ProbeBwMode::EnterProbeUp(QuicTime now) {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
   QUIC_DVLOG(2) << sender_ << " Phase change: " << cycle_.phase << " ==> "
                 << CyclePhase::PROBE_UP << " after "
                 << now - cycle_.phase_start_time << ", or "
@@ -568,7 +568,7 @@
 }
 
 void Bbr2ProbeBwMode::ExitProbeDown() {
-  DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
+  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
   if (!cycle_.has_advanced_max_bw) {
     QUIC_DVLOG(2) << sender_ << " Advancing max bw filter at end of cycle.";
     model_->AdvanceMaxBandwidthFilter();
diff --git a/quic/core/congestion_control/bbr2_sender.cc b/quic/core/congestion_control/bbr2_sender.cc
index 0d6b3f1..e8ef762 100644
--- a/quic/core/congestion_control/bbr2_sender.cc
+++ b/quic/core/congestion_control/bbr2_sender.cc
@@ -90,7 +90,7 @@
   QUIC_DVLOG(2) << this << " Initializing Bbr2Sender. mode:" << mode_
                 << ", PacingRate:" << pacing_rate_ << ", Cwnd:" << cwnd_
                 << ", CwndLimits:" << cwnd_limits() << "  @ " << now;
-  DCHECK_EQ(mode_, Bbr2Mode::STARTUP);
+  QUICHE_DCHECK_EQ(mode_, Bbr2Mode::STARTUP);
 }
 
 void Bbr2Sender::SetFromConfig(const QuicConfig& config,
diff --git a/quic/core/congestion_control/bbr2_simulator_test.cc b/quic/core/congestion_control/bbr2_simulator_test.cc
index 489a958..9cd5966 100644
--- a/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -1286,7 +1286,7 @@
   QuicBandwidth BottleneckBandwidth() const {
     // Make sure all local links have a higher bandwidth than the test link.
     for (size_t i = 0; i < local_links.size(); ++i) {
-      CHECK_GT(local_links[i].bandwidth, test_link.bandwidth);
+      QUICHE_CHECK_GT(local_links[i].bandwidth, test_link.bandwidth);
     }
     return test_link.bandwidth;
   }
diff --git a/quic/core/congestion_control/bbr2_startup.cc b/quic/core/congestion_control/bbr2_startup.cc
index 7904eb3..0f6b80f 100644
--- a/quic/core/congestion_control/bbr2_startup.cc
+++ b/quic/core/congestion_control/bbr2_startup.cc
@@ -62,8 +62,8 @@
   }
 
   if (Params().decrease_startup_pacing_at_end_of_round) {
-    DCHECK_GT(model_->pacing_gain(), 0);
-    DCHECK(Params().bw_startup);
+    QUICHE_DCHECK_GT(model_->pacing_gain(), 0);
+    QUICHE_DCHECK(Params().bw_startup);
     if (congestion_event.end_of_round_trip &&
         !congestion_event.last_sample_is_app_limited) {
       // Multiply by startup_pacing_gain, so if the bandwidth doubles,
@@ -104,7 +104,7 @@
 
 void Bbr2StartupMode::CheckExcessiveLosses(
     const Bbr2CongestionEvent& congestion_event) {
-  DCHECK(congestion_event.end_of_round_trip);
+  QUICHE_DCHECK(congestion_event.end_of_round_trip);
 
   if (model_->full_bandwidth_reached()) {
     return;
diff --git a/quic/core/congestion_control/cubic_bytes.cc b/quic/core/congestion_control/cubic_bytes.cc
index 482704e..854d6a7 100644
--- a/quic/core/congestion_control/cubic_bytes.cc
+++ b/quic/core/congestion_control/cubic_bytes.cc
@@ -153,8 +153,8 @@
                                           kCubeScale;
 
   const bool add_delta = elapsed_time > time_to_origin_point_;
-  DCHECK(add_delta ||
-         (origin_point_congestion_window_ > delta_congestion_window));
+  QUICHE_DCHECK(add_delta ||
+                (origin_point_congestion_window_ > delta_congestion_window));
   QuicByteCount target_congestion_window =
       add_delta ? origin_point_congestion_window_ + delta_congestion_window
                 : origin_point_congestion_window_ - delta_congestion_window;
@@ -163,7 +163,7 @@
       std::min(target_congestion_window,
                current_congestion_window + acked_bytes_count_ / 2);
 
-  DCHECK_LT(0u, estimated_tcp_congestion_window_);
+  QUICHE_DCHECK_LT(0u, estimated_tcp_congestion_window_);
   // Increase the window by approximately Alpha * 1 MSS of bytes every
   // time we ack an estimated tcp window of bytes.  For small
   // congestion windows (less than 25), the formula below will
diff --git a/quic/core/congestion_control/general_loss_algorithm.cc b/quic/core/congestion_control/general_loss_algorithm.cc
index 478ab7d..521aa4a 100644
--- a/quic/core/congestion_control/general_loss_algorithm.cc
+++ b/quic/core/congestion_control/general_loss_algorithm.cc
@@ -79,8 +79,8 @@
   }
   // Clear least_in_flight_.
   least_in_flight_.Clear();
-  DCHECK_EQ(packet_number_space_,
-            unacked_packets.GetPacketNumberSpace(largest_newly_acked));
+  QUICHE_DCHECK_EQ(packet_number_space_,
+                   unacked_packets.GetPacketNumberSpace(largest_newly_acked));
   for (; it != unacked_packets.end() && packet_number <= largest_newly_acked;
        ++it, ++packet_number) {
     if (unacked_packets.GetPacketNumberSpace(it->encryption_level) !=
@@ -169,7 +169,7 @@
   }
 
   if (use_adaptive_reordering_threshold_) {
-    DCHECK_LT(packet_number, previous_largest_acked);
+    QUICHE_DCHECK_LT(packet_number, previous_largest_acked);
     // Increase reordering_threshold_ such that packet_number would not have
     // been declared lost.
     reordering_threshold_ = std::max(
diff --git a/quic/core/congestion_control/pacing_sender.cc b/quic/core/congestion_control/pacing_sender.cc
index 7389a46..a43601e 100644
--- a/quic/core/congestion_control/pacing_sender.cc
+++ b/quic/core/congestion_control/pacing_sender.cc
@@ -35,7 +35,7 @@
 PacingSender::~PacingSender() {}
 
 void PacingSender::set_sender(SendAlgorithmInterface* sender) {
-  DCHECK(sender != nullptr);
+  QUICHE_DCHECK(sender != nullptr);
   sender_ = sender;
 }
 
@@ -44,7 +44,7 @@
                                      QuicTime event_time,
                                      const AckedPacketVector& acked_packets,
                                      const LostPacketVector& lost_packets) {
-  DCHECK(sender_ != nullptr);
+  QUICHE_DCHECK(sender_ != nullptr);
   if (!lost_packets.empty()) {
     // Clear any burst tokens when entering recovery.
     burst_tokens_ = 0;
@@ -59,7 +59,7 @@
     QuicPacketNumber packet_number,
     QuicByteCount bytes,
     HasRetransmittableData has_retransmittable_data) {
-  DCHECK(sender_ != nullptr);
+  QUICHE_DCHECK(sender_ != nullptr);
   sender_->OnPacketSent(sent_time, bytes_in_flight, packet_number, bytes,
                         has_retransmittable_data);
   if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA) {
@@ -130,7 +130,7 @@
 QuicTime::Delta PacingSender::TimeUntilSend(
     QuicTime now,
     QuicByteCount bytes_in_flight) const {
-  DCHECK(sender_ != nullptr);
+  QUICHE_DCHECK(sender_ != nullptr);
 
   if (!sender_->CanSend(bytes_in_flight)) {
     // The underlying sender prevents sending.
@@ -158,7 +158,7 @@
 }
 
 QuicBandwidth PacingSender::PacingRate(QuicByteCount bytes_in_flight) const {
-  DCHECK(sender_ != nullptr);
+  QUICHE_DCHECK(sender_ != nullptr);
   if (!max_pacing_rate_.IsZero()) {
     return QuicBandwidth::FromBitsPerSecond(
         std::min(max_pacing_rate_.ToBitsPerSecond(),
diff --git a/quic/core/congestion_control/rtt_stats.cc b/quic/core/congestion_control/rtt_stats.cc
index 8754966..2be6fa4 100644
--- a/quic/core/congestion_control/rtt_stats.cc
+++ b/quic/core/congestion_control/rtt_stats.cc
@@ -103,7 +103,7 @@
 }
 
 QuicTime::Delta RttStats::GetStandardOrMeanDeviation() const {
-  DCHECK(calculate_standard_deviation_);
+  QUICHE_DCHECK(calculate_standard_deviation_);
   if (!standard_deviation_calculator_.has_valid_standard_deviation) {
     return mean_deviation_;
   }
@@ -124,7 +124,7 @@
 
 QuicTime::Delta
 RttStats::StandardDeviationCaculator::CalculateStandardDeviation() const {
-  DCHECK(has_valid_standard_deviation);
+  QUICHE_DCHECK(has_valid_standard_deviation);
   return QuicTime::Delta::FromMicroseconds(sqrt(m2));
 }
 
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
index 73b4c8a..77691fd 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
@@ -178,8 +178,8 @@
     // PRR is used when in recovery.
     prr_.OnPacketSent(bytes);
   }
-  DCHECK(!largest_sent_packet_number_.IsInitialized() ||
-         largest_sent_packet_number_ < packet_number);
+  QUICHE_DCHECK(!largest_sent_packet_number_.IsInitialized() ||
+                largest_sent_packet_number_ < packet_number);
   largest_sent_packet_number_ = packet_number;
   hybrid_slow_start_.OnPacketSent(packet_number);
 }
@@ -323,7 +323,7 @@
 
   // TODO(b/77268641): Separate out all of slow start into a separate class.
   if (slow_start_large_reduction_ && InSlowStart()) {
-    DCHECK_LT(kDefaultTCPMSS, congestion_window_);
+    QUICHE_DCHECK_LT(kDefaultTCPMSS, congestion_window_);
     if (congestion_window_ >= 2 * initial_tcp_congestion_window_) {
       min_slow_start_exit_window_ = congestion_window_ / 2;
     }
diff --git a/quic/core/crypto/aead_base_decrypter.cc b/quic/core/crypto/aead_base_decrypter.cc
index a40d1b5..32a2ebf 100644
--- a/quic/core/crypto/aead_base_decrypter.cc
+++ b/quic/core/crypto/aead_base_decrypter.cc
@@ -60,17 +60,17 @@
       nonce_size_(nonce_size),
       use_ietf_nonce_construction_(use_ietf_nonce_construction),
       have_preliminary_key_(false) {
-  DCHECK_GT(256u, key_size);
-  DCHECK_GT(256u, auth_tag_size);
-  DCHECK_GT(256u, nonce_size);
-  DCHECK_LE(key_size_, sizeof(key_));
-  DCHECK_LE(nonce_size_, sizeof(iv_));
+  QUICHE_DCHECK_GT(256u, key_size);
+  QUICHE_DCHECK_GT(256u, auth_tag_size);
+  QUICHE_DCHECK_GT(256u, nonce_size);
+  QUICHE_DCHECK_LE(key_size_, sizeof(key_));
+  QUICHE_DCHECK_LE(nonce_size_, sizeof(iv_));
 }
 
 AeadBaseDecrypter::~AeadBaseDecrypter() {}
 
 bool AeadBaseDecrypter::SetKey(absl::string_view key) {
-  DCHECK_EQ(key.size(), key_size_);
+  QUICHE_DCHECK_EQ(key.size(), key_size_);
   if (key.size() != key_size_) {
     return false;
   }
@@ -91,7 +91,7 @@
     QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter";
     return false;
   }
-  DCHECK_EQ(nonce_prefix.size(), nonce_size_ - sizeof(QuicPacketNumber));
+  QUICHE_DCHECK_EQ(nonce_prefix.size(), nonce_size_ - sizeof(QuicPacketNumber));
   if (nonce_prefix.size() != nonce_size_ - sizeof(QuicPacketNumber)) {
     return false;
   }
@@ -104,7 +104,7 @@
     QUIC_BUG << "Attempted to set IV on Google QUIC crypter";
     return false;
   }
-  DCHECK_EQ(iv.size(), nonce_size_);
+  QUICHE_DCHECK_EQ(iv.size(), nonce_size_);
   if (iv.size() != nonce_size_) {
     return false;
   }
@@ -113,7 +113,7 @@
 }
 
 bool AeadBaseDecrypter::SetPreliminaryKey(absl::string_view key) {
-  DCHECK(!have_preliminary_key_);
+  QUICHE_DCHECK(!have_preliminary_key_);
   SetKey(key);
   have_preliminary_key_ = true;
 
@@ -139,7 +139,7 @@
   if (!SetKey(key) ||
       (!use_ietf_nonce_construction_ && !SetNoncePrefix(nonce_prefix)) ||
       (use_ietf_nonce_construction_ && !SetIV(nonce_prefix))) {
-    DCHECK(false);
+    QUICHE_DCHECK(false);
     return false;
   }
 
diff --git a/quic/core/crypto/aead_base_encrypter.cc b/quic/core/crypto/aead_base_encrypter.cc
index c4a0ddd..a7100c5 100644
--- a/quic/core/crypto/aead_base_encrypter.cc
+++ b/quic/core/crypto/aead_base_encrypter.cc
@@ -51,15 +51,15 @@
       auth_tag_size_(auth_tag_size),
       nonce_size_(nonce_size),
       use_ietf_nonce_construction_(use_ietf_nonce_construction) {
-  DCHECK_LE(key_size_, sizeof(key_));
-  DCHECK_LE(nonce_size_, sizeof(iv_));
-  DCHECK_GE(kMaxNonceSize, nonce_size_);
+  QUICHE_DCHECK_LE(key_size_, sizeof(key_));
+  QUICHE_DCHECK_LE(nonce_size_, sizeof(iv_));
+  QUICHE_DCHECK_GE(kMaxNonceSize, nonce_size_);
 }
 
 AeadBaseEncrypter::~AeadBaseEncrypter() {}
 
 bool AeadBaseEncrypter::SetKey(absl::string_view key) {
-  DCHECK_EQ(key.size(), key_size_);
+  QUICHE_DCHECK_EQ(key.size(), key_size_);
   if (key.size() != key_size_) {
     return false;
   }
@@ -81,7 +81,7 @@
     QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter";
     return false;
   }
-  DCHECK_EQ(nonce_prefix.size(), nonce_size_ - sizeof(QuicPacketNumber));
+  QUICHE_DCHECK_EQ(nonce_prefix.size(), nonce_size_ - sizeof(QuicPacketNumber));
   if (nonce_prefix.size() != nonce_size_ - sizeof(QuicPacketNumber)) {
     return false;
   }
@@ -94,7 +94,7 @@
     QUIC_BUG << "Attempted to set IV on Google QUIC crypter";
     return false;
   }
-  DCHECK_EQ(iv.size(), nonce_size_);
+  QUICHE_DCHECK_EQ(iv.size(), nonce_size_);
   if (iv.size() != nonce_size_) {
     return false;
   }
@@ -106,7 +106,7 @@
                                 absl::string_view associated_data,
                                 absl::string_view plaintext,
                                 unsigned char* output) {
-  DCHECK_EQ(nonce.size(), nonce_size_);
+  QUICHE_DCHECK_EQ(nonce.size(), nonce_size_);
 
   size_t ciphertext_len;
   if (!EVP_AEAD_CTX_seal(
diff --git a/quic/core/crypto/cert_compressor.cc b/quic/core/crypto/cert_compressor.cc
index 5e2cf83..e2a352d 100644
--- a/quic/core/crypto/cert_compressor.cc
+++ b/quic/core/crypto/cert_compressor.cc
@@ -308,7 +308,7 @@
   zlib_dict += std::string(reinterpret_cast<const char*>(kCommonCertSubstrings),
                            sizeof(kCommonCertSubstrings));
 
-  DCHECK_EQ(zlib_dict.size(), zlib_dict_size);
+  QUICHE_DCHECK_EQ(zlib_dict.size(), zlib_dict_size);
 
   return zlib_dict;
 }
@@ -456,7 +456,7 @@
     const CommonCertSets* common_sets) {
   const std::vector<CertEntry> entries = MatchCerts(
       certs, client_common_set_hashes, client_cached_cert_hashes, common_sets);
-  DCHECK_EQ(entries.size(), certs.size());
+  QUICHE_DCHECK_EQ(entries.size(), certs.size());
 
   size_t uncompressed_size = 0;
   for (size_t i = 0; i < entries.size(); i++) {
@@ -472,7 +472,7 @@
   if (uncompressed_size > 0) {
     memset(&z, 0, sizeof(z));
     int rv = deflateInit(&z, Z_DEFAULT_COMPRESSION);
-    DCHECK_EQ(Z_OK, rv);
+    QUICHE_DCHECK_EQ(Z_OK, rv);
     if (rv != Z_OK) {
       return "";
     }
@@ -482,7 +482,7 @@
 
     rv = deflateSetDictionary(
         &z, reinterpret_cast<const uint8_t*>(&zlib_dict[0]), zlib_dict.size());
-    DCHECK_EQ(Z_OK, rv);
+    QUICHE_DCHECK_EQ(Z_OK, rv);
     if (rv != Z_OK) {
       return "";
     }
@@ -522,8 +522,8 @@
     z.next_in = reinterpret_cast<uint8_t*>(&length32);
     z.avail_in = sizeof(length32);
     rv = deflate(&z, Z_NO_FLUSH);
-    DCHECK_EQ(Z_OK, rv);
-    DCHECK_EQ(0u, z.avail_in);
+    QUICHE_DCHECK_EQ(Z_OK, rv);
+    QUICHE_DCHECK_EQ(0u, z.avail_in);
     if (rv != Z_OK || z.avail_in) {
       return "";
     }
@@ -532,8 +532,8 @@
         const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(certs[i].data()));
     z.avail_in = certs[i].size();
     rv = deflate(&z, Z_NO_FLUSH);
-    DCHECK_EQ(Z_OK, rv);
-    DCHECK_EQ(0u, z.avail_in);
+    QUICHE_DCHECK_EQ(Z_OK, rv);
+    QUICHE_DCHECK_EQ(0u, z.avail_in);
     if (rv != Z_OK || z.avail_in) {
       return "";
     }
@@ -541,7 +541,7 @@
 
   z.avail_in = 0;
   rv = deflate(&z, Z_FINISH);
-  DCHECK_EQ(Z_STREAM_END, rv);
+  QUICHE_DCHECK_EQ(Z_STREAM_END, rv);
   if (rv != Z_STREAM_END) {
     return "";
   }
@@ -560,7 +560,7 @@
   if (!ParseEntries(&in, cached_certs, common_sets, &entries, out_certs)) {
     return false;
   }
-  DCHECK_EQ(entries.size(), out_certs->size());
+  QUICHE_DCHECK_EQ(entries.size(), out_certs->size());
 
   std::unique_ptr<uint8_t[]> uncompressed_data;
   absl::string_view uncompressed;
diff --git a/quic/core/crypto/certificate_view.cc b/quic/core/crypto/certificate_view.cc
index 629373d..7a20602 100644
--- a/quic/core/crypto/certificate_view.cc
+++ b/quic/core/crypto/certificate_view.cc
@@ -196,7 +196,7 @@
   }
 
   if (tag == CBS_ASN1_UTCTIME) {
-    DCHECK_LE(year, 100u);
+    QUICHE_DCHECK_LE(year, 100u);
     year += (year >= 50) ? 1900 : 2000;
   }
 
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc
index 8dd3679..cf6e123 100644
--- a/quic/core/crypto/crypto_framer.cc
+++ b/quic/core/crypto/crypto_framer.cc
@@ -87,13 +87,13 @@
 }
 
 bool CryptoFramer::ProcessInput(absl::string_view input) {
-  DCHECK_EQ(QUIC_NO_ERROR, error_);
+  QUICHE_DCHECK_EQ(QUIC_NO_ERROR, error_);
   if (error_ != QUIC_NO_ERROR) {
     return false;
   }
   error_ = Process(input);
   if (error_ != QUIC_NO_ERROR) {
-    DCHECK(!error_detail_.empty());
+    QUICHE_DCHECK(!error_detail_.empty());
     visitor_->OnError(this);
     return false;
   }
@@ -160,15 +160,15 @@
   std::unique_ptr<char[]> buffer(new char[len]);
   QuicDataWriter writer(len, buffer.get(), quiche::HOST_BYTE_ORDER);
   if (!writer.WriteTag(message.tag())) {
-    DCHECK(false) << "Failed to write message tag.";
+    QUICHE_DCHECK(false) << "Failed to write message tag.";
     return nullptr;
   }
   if (!writer.WriteUInt16(static_cast<uint16_t>(num_entries))) {
-    DCHECK(false) << "Failed to write size.";
+    QUICHE_DCHECK(false) << "Failed to write size.";
     return nullptr;
   }
   if (!writer.WriteUInt16(0)) {
-    DCHECK(false) << "Failed to write padding.";
+    QUICHE_DCHECK(false) << "Failed to write padding.";
     return nullptr;
   }
 
@@ -180,7 +180,8 @@
       // Existing PAD tags are only checked when padding needs to be added
       // because parts of the code may need to reserialize received messages
       // and those messages may, legitimately include padding.
-      DCHECK(false) << "Message needed padding but already contained a PAD tag";
+      QUICHE_DCHECK(false)
+          << "Message needed padding but already contained a PAD tag";
       return nullptr;
     }
 
@@ -192,12 +193,12 @@
     }
 
     if (!writer.WriteTag(it->first)) {
-      DCHECK(false) << "Failed to write tag.";
+      QUICHE_DCHECK(false) << "Failed to write tag.";
       return nullptr;
     }
     end_offset += it->second.length();
     if (!writer.WriteUInt32(end_offset)) {
-      DCHECK(false) << "Failed to write end offset.";
+      QUICHE_DCHECK(false) << "Failed to write end offset.";
       return nullptr;
     }
   }
@@ -214,20 +215,20 @@
     if (it->first > kPAD && need_pad_value) {
       need_pad_value = false;
       if (!writer.WriteRepeatedByte('-', pad_length)) {
-        DCHECK(false) << "Failed to write padding.";
+        QUICHE_DCHECK(false) << "Failed to write padding.";
         return nullptr;
       }
     }
 
     if (!writer.WriteBytes(it->second.data(), it->second.length())) {
-      DCHECK(false) << "Failed to write value.";
+      QUICHE_DCHECK(false) << "Failed to write value.";
       return nullptr;
     }
   }
 
   if (need_pad_value) {
     if (!writer.WriteRepeatedByte('-', pad_length)) {
-      DCHECK(false) << "Failed to write padding.";
+      QUICHE_DCHECK(false) << "Failed to write padding.";
       return nullptr;
     }
   }
@@ -321,7 +322,7 @@
       for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) {
         absl::string_view value;
         if (!reader.ReadStringPiece(&value, item.second)) {
-          DCHECK(process_truncated_messages_);
+          QUICHE_DCHECK(process_truncated_messages_);
           // Store an empty value.
           message_.SetStringPiece(item.first, "");
           continue;
@@ -343,12 +344,12 @@
                                size_t pad_length,
                                uint32_t* end_offset) {
   if (!writer->WriteTag(kPAD)) {
-    DCHECK(false) << "Failed to write tag.";
+    QUICHE_DCHECK(false) << "Failed to write tag.";
     return false;
   }
   *end_offset += pad_length;
   if (!writer->WriteUInt32(*end_offset)) {
-    DCHECK(false) << "Failed to write end offset.";
+    QUICHE_DCHECK(false) << "Failed to write end offset.";
     return false;
   }
   return true;
diff --git a/quic/core/crypto/crypto_secret_boxer.cc b/quic/core/crypto/crypto_secret_boxer.cc
index 0c24c2c..1826212 100644
--- a/quic/core/crypto/crypto_secret_boxer.cc
+++ b/quic/core/crypto/crypto_secret_boxer.cc
@@ -45,12 +45,12 @@
 static const EVP_AEAD* (*const kAEAD)() = EVP_aead_aes_256_gcm_siv;
 
 void CryptoSecretBoxer::SetKeys(const std::vector<std::string>& keys) {
-  DCHECK(!keys.empty());
+  QUICHE_DCHECK(!keys.empty());
   const EVP_AEAD* const aead = kAEAD();
   std::unique_ptr<State> new_state(new State);
 
   for (const std::string& key : keys) {
-    DCHECK_EQ(kBoxKeySize, key.size());
+    QUICHE_DCHECK_EQ(kBoxKeySize, key.size());
     bssl::UniquePtr<EVP_AEAD_CTX> ctx(
         EVP_AEAD_CTX_new(aead, reinterpret_cast<const uint8_t*>(key.data()),
                          key.size(), EVP_AEAD_DEFAULT_TAG_LENGTH));
@@ -100,7 +100,7 @@
     }
   }
 
-  DCHECK_EQ(out_len, bytes_written);
+  QUICHE_DCHECK_EQ(out_len, bytes_written);
   return ret;
 }
 
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index a6ab228..323aec1 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -48,7 +48,7 @@
   void Run(bool /*ok*/,
            const std::string& /*error_details*/,
            std::unique_ptr<ProofVerifyDetails>* /*details*/) override {
-    DCHECK(false);
+    QUICHE_DCHECK(false);
   }
 };
 
@@ -129,8 +129,8 @@
         config_.AddConfig(primary_config, clock_.WallNow()));
 
     absl::string_view orbit;
-    CHECK(msg->GetStringPiece(kORBT, &orbit));
-    CHECK_EQ(sizeof(orbit_), orbit.size());
+    QUICHE_CHECK(msg->GetStringPiece(kORBT, &orbit));
+    QUICHE_CHECK_EQ(sizeof(orbit_), orbit.size());
     memcpy(orbit_, orbit.data(), orbit.size());
 
     char public_value[32];
@@ -171,7 +171,7 @@
 
     signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>(
         new QuicSignedServerConfig());
-    DCHECK(signed_config_->chain.get() == nullptr);
+    QUICHE_DCHECK(signed_config_->chain.get() == nullptr);
   }
 
   // Helper used to accept the result of ValidateClientHello and pass
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index ed63e3c..113d9cf 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -504,7 +504,7 @@
       break;
     }
     default:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
   }
 
   if (subkey_secret != nullptr) {
@@ -552,7 +552,7 @@
     const CryptoHandshakeMessage& server_hello,
     const ParsedQuicVersionVector& negotiated_versions,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   if (server_hello.tag() != kSHLO) {
     *error_details = "Bad tag";
diff --git a/quic/core/crypto/proof_source_x509_test.cc b/quic/core/crypto/proof_source_x509_test.cc
index f72e2f5..75a6099 100644
--- a/quic/core/crypto/proof_source_x509_test.cc
+++ b/quic/core/crypto/proof_source_x509_test.cc
@@ -36,8 +36,8 @@
             CertificatePrivateKey::LoadFromDer(kTestCertificatePrivateKey)),
         wildcard_key_(CertificatePrivateKey::LoadFromDer(
             kWildcardCertificatePrivateKey)) {
-    CHECK(test_key_ != nullptr);
-    CHECK(wildcard_key_ != nullptr);
+    QUICHE_CHECK(test_key_ != nullptr);
+    QUICHE_CHECK(wildcard_key_ != nullptr);
   }
 
  protected:
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index aabff94..45db92b 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -70,7 +70,7 @@
       session_cache_(std::move(session_cache)),
       ssl_ctx_(TlsClientConnection::CreateSslCtx(
           !GetQuicFlag(FLAGS_quic_disable_client_tls_zero_rtt))) {
-  DCHECK(proof_verifier_.get());
+  QUICHE_DCHECK(proof_verifier_.get());
   SetDefaults();
 }
 
@@ -98,7 +98,7 @@
   if (!scfg) {
     // Should be impossible short of cache corruption.
     RecordInchoateClientHelloReason(SERVER_CONFIG_CORRUPTED);
-    DCHECK(false);
+    QUICHE_DCHECK(false);
     return false;
   }
 
@@ -129,7 +129,7 @@
 
   if (!scfg_) {
     scfg_ = CryptoFramer::ParseMessage(server_config_);
-    DCHECK(scfg_.get());
+    QUICHE_DCHECK(scfg_.get());
   }
   return scfg_.get();
 }
@@ -266,7 +266,7 @@
     absl::string_view signature,
     QuicWallTime now,
     QuicWallTime expiration_time) {
-  DCHECK(server_config_.empty());
+  QUICHE_DCHECK(server_config_.empty());
 
   if (server_config.empty()) {
     RecordDiskCacheServerConfigState(SERVER_CONFIG_EMPTY);
@@ -347,8 +347,8 @@
 
 void QuicCryptoClientConfig::CachedState::InitializeFrom(
     const QuicCryptoClientConfig::CachedState& other) {
-  DCHECK(server_config_.empty());
-  DCHECK(!server_config_valid_);
+  QUICHE_DCHECK(server_config_.empty());
+  QUICHE_DCHECK(!server_config_valid_);
   server_config_ = other.server_config_;
   source_address_token_ = other.source_address_token_;
   certs_ = other.certs_;
@@ -494,7 +494,7 @@
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     CryptoHandshakeMessage* out,
     std::string* error_details) const {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(
       connection_id, preferred_version.transport_version))
       << "FillClientHello: attempted to use connection ID " << connection_id
@@ -574,7 +574,7 @@
           P256KeyExchange::New(P256KeyExchange::NewPrivateKey());
       break;
     default:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       *error_details = "Configured to support an unknown key exchange";
       return QUIC_CRYPTO_INTERNAL_ERROR;
   }
@@ -639,7 +639,7 @@
     const std::vector<std::string>& cached_certs,
     CachedState* cached,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   absl::string_view scfg;
   if (!message.GetStringPiece(kSCFG, &scfg)) {
@@ -711,7 +711,7 @@
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   if (rej.tag() != kREJ) {
     *error_details = "Message is not REJ";
@@ -741,7 +741,7 @@
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   QuicErrorCode valid = CryptoUtils::ValidateServerHello(
       server_hello, negotiated_versions, error_details);
@@ -804,7 +804,7 @@
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   if (server_config_update.tag() != kSCUP) {
     *error_details = "ServerConfigUpdate must have kSCUP tag.";
@@ -855,7 +855,7 @@
 bool QuicCryptoClientConfig::PopulateFromCanonicalConfig(
     const QuicServerId& server_id,
     CachedState* server_state) {
-  DCHECK(server_state->IsEmpty());
+  QUICHE_DCHECK(server_state->IsEmpty());
   size_t i = 0;
   for (; i < canonical_suffixes_.size(); ++i) {
     if (absl::EndsWithIgnoreCase(server_id.host(), canonical_suffixes_[i])) {
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 0e9bca8..da04f4f 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -255,7 +255,7 @@
       pad_shlo_(true),
       validate_chlo_size_(true),
       validate_source_address_token_(true) {
-  DCHECK(proof_source_.get());
+  QUICHE_DCHECK(proof_source_.get());
   source_address_token_boxer_.SetKeys(
       {DeriveSourceAddressTokenKey(source_address_token_secret)});
 
@@ -287,7 +287,7 @@
 
   std::string encoded_public_values;
   // First three bytes encode the length of the public value.
-  DCHECK_LT(curve25519_public_value.size(), (1U << 24));
+  QUICHE_DCHECK_LT(curve25519_public_value.size(), (1U << 24));
   encoded_public_values.push_back(
       static_cast<char>(curve25519_public_value.size()));
   encoded_public_values.push_back(
@@ -304,7 +304,7 @@
         P256KeyExchange::New(p256_private_key));
     absl::string_view p256_public_value = p256->public_value();
 
-    DCHECK_LT(p256_public_value.size(), (1U << 24));
+    QUICHE_DCHECK_LT(p256_public_value.size(), (1U << 24));
     encoded_public_values.push_back(
         static_cast<char>(p256_public_value.size()));
     encoded_public_values.push_back(
@@ -338,7 +338,7 @@
   if (options.orbit.size() == sizeof(orbit_bytes)) {
     memcpy(orbit_bytes, options.orbit.data(), sizeof(orbit_bytes));
   } else {
-    DCHECK(options.orbit.empty());
+    QUICHE_DCHECK(options.orbit.empty());
     rand->RandBytes(orbit_bytes, sizeof(orbit_bytes));
   }
   msg.SetStringPiece(kORBT,
@@ -416,9 +416,9 @@
 
     configs_[config->id] = config;
     SelectNewPrimaryConfig(now);
-    DCHECK(primary_config_.get());
-    DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
-              primary_config_.get());
+    QUICHE_DCHECK(primary_config_.get());
+    QUICHE_DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
+                     primary_config_.get());
   }
 
   return msg;
@@ -506,9 +506,9 @@
   configs_ = std::move(new_configs);
   fallback_config_ = fallback_config;
   SelectNewPrimaryConfig(now);
-  DCHECK(primary_config_.get());
-  DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
-            primary_config_.get());
+  QUICHE_DCHECK(primary_config_.get());
+  QUICHE_DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
+                   primary_config_.get());
 
   return true;
 }
@@ -672,7 +672,7 @@
     QuicByteCount total_framing_overhead,
     QuicByteCount chlo_packet_size,
     std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const {
-  DCHECK(done_cb);
+  QUICHE_DCHECK(done_cb);
   auto context = std::make_unique<ProcessClientHelloContext>(
       validate_chlo_result, reject_only, connection_id, server_address,
       client_address, version, supported_versions, clock, rand,
@@ -720,7 +720,7 @@
     auto cb = std::make_unique<ProcessClientHelloCallback>(
         this, std::move(context), configs);
 
-    DCHECK(proof_source_.get());
+    QUICHE_DCHECK(proof_source_.get());
     proof_source_->GetProof(server_address, client_address, sni,
                             configs.primary->serialized, transport_version,
                             chlo_hash, std::move(cb));
@@ -862,7 +862,7 @@
   hkdf_suffix.append(client_hello_serialized.data(),
                      client_hello_serialized.length());
   hkdf_suffix.append(configs.requested->serialized);
-  DCHECK(proof_source_.get());
+  QUICHE_DCHECK(proof_source_.get());
   if (context->signed_config()->chain->certs.empty()) {
     context->Fail(QUIC_CRYPTO_INTERNAL_ERROR, "Failed to get certs");
     return;
@@ -1085,9 +1085,9 @@
     configs_lock_.ReaderUnlock();
     configs_lock_.WriterLock();
     SelectNewPrimaryConfig(now);
-    DCHECK(primary_config_.get());
-    DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
-              primary_config_.get());
+    QUICHE_DCHECK(primary_config_.get());
+    QUICHE_DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
+                     primary_config_.get());
     configs_lock_.WriterUnlock();
     configs_lock_.ReaderLock();
   }
@@ -1450,7 +1450,7 @@
   }
 
   // Send client the reject reason for debugging purposes.
-  DCHECK_LT(0u, reject_reasons.size());
+  QUICHE_DCHECK_LT(0u, reject_reasons.size());
   out->SetVector(kRREJ, reject_reasons);
 
   // The client may have requested a certificate chain.
@@ -1479,7 +1479,7 @@
       context.params()->client_common_set_hashes,
       context.params()->client_cached_cert_hashes, config.common_cert_sets);
 
-  DCHECK_GT(context.chlo_packet_size(), context.client_hello().size());
+  QUICHE_DCHECK_GT(context.chlo_packet_size(), context.client_hello().size());
   // kREJOverheadBytes is a very rough estimate of how much of a REJ
   // message is taken up by things other than the certificates.
   // STK: 56 bytes
@@ -1549,7 +1549,7 @@
     const std::string& client_cached_cert_hashes,
     const CommonCertSets* common_sets) {
   // Check whether the compressed certs is available in the cache.
-  DCHECK(compressed_certs_cache);
+  QUICHE_DCHECK(compressed_certs_cache);
   const std::string* cached_value = compressed_certs_cache->GetCompressedCert(
       chain, client_common_set_hashes, client_cached_cert_hashes);
   if (cached_value) {
diff --git a/quic/core/crypto/quic_hkdf.cc b/quic/core/crypto/quic_hkdf.cc
index 9cfac5f..8dcf104 100644
--- a/quic/core/crypto/quic_hkdf.cc
+++ b/quic/core/crypto/quic_hkdf.cc
@@ -43,7 +43,7 @@
       2 * client_key_bytes_to_generate + client_iv_bytes_to_generate +
       2 * server_key_bytes_to_generate + server_iv_bytes_to_generate +
       subkey_secret_bytes_to_generate;
-  DCHECK_LT(material_length, kMaxKeyMaterialSize);
+  QUICHE_DCHECK_LT(material_length, kMaxKeyMaterialSize);
 
   output_.resize(material_length);
   // On Windows, when the size of output_ is zero, dereference of 0'th element
diff --git a/quic/core/crypto/tls_connection.cc b/quic/core/crypto/tls_connection.cc
index 4a39a4e..9b5636c 100644
--- a/quic/core/crypto/tls_connection.cc
+++ b/quic/core/crypto/tls_connection.cc
@@ -36,7 +36,7 @@
     CRYPTO_library_init();
     ssl_ex_data_index_connection_ =
         SSL_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
-    CHECK_LE(0, ssl_ex_data_index_connection_);
+    QUICHE_CHECK_LE(0, ssl_ex_data_index_connection_);
   }
 
   SslIndexSingleton(const SslIndexSingleton&) = delete;
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index a948990..8cbd06e 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -179,9 +179,9 @@
       min_value_(min_value),
       max_value_(max_value),
       has_been_read_(false) {
-  DCHECK_LE(min_value, default_value);
-  DCHECK_LE(default_value, max_value);
-  DCHECK_LE(max_value, kVarInt62MaxValue);
+  QUICHE_DCHECK_LE(min_value, default_value);
+  QUICHE_DCHECK_LE(default_value, max_value);
+  QUICHE_DCHECK_LE(max_value, kVarInt62MaxValue);
 }
 
 TransportParameters::IntegerParameter::IntegerParameter(
@@ -206,7 +206,7 @@
 
 bool TransportParameters::IntegerParameter::Write(
     QuicDataWriter* writer) const {
-  DCHECK(IsValid());
+  QUICHE_DCHECK(IsValid());
   if (value_ == default_value_) {
     // Do not write if the value is default.
     return true;
@@ -532,8 +532,8 @@
 }
 
 bool TransportParameters::AreValid(std::string* error_details) const {
-  DCHECK(perspective == Perspective::IS_CLIENT ||
-         perspective == Perspective::IS_SERVER);
+  QUICHE_DCHECK(perspective == Perspective::IS_CLIENT ||
+                perspective == Perspective::IS_SERVER);
   if (perspective == Perspective::IS_CLIENT && !stateless_reset_token.empty()) {
     *error_details = "Client cannot send stateless reset token";
     return false;
@@ -693,7 +693,7 @@
 
   // original_destination_connection_id
   if (in.original_destination_connection_id.has_value()) {
-    DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
     QuicConnectionId original_destination_connection_id =
         in.original_destination_connection_id.value();
     if (!writer.WriteVarInt62(
@@ -714,8 +714,9 @@
 
   // stateless_reset_token
   if (!in.stateless_reset_token.empty()) {
-    DCHECK_EQ(kStatelessResetTokenLength, in.stateless_reset_token.size());
-    DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
+    QUICHE_DCHECK_EQ(kStatelessResetTokenLength,
+                     in.stateless_reset_token.size());
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
     if (!writer.WriteVarInt62(TransportParameters::kStatelessResetToken) ||
         !writer.WriteStringPieceVarInt62(absl::string_view(
             reinterpret_cast<const char*>(in.stateless_reset_token.data()),
@@ -804,7 +805,7 @@
 
   // retry_source_connection_id
   if (in.retry_source_connection_id.has_value()) {
-    DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
     QuicConnectionId retry_source_connection_id =
         in.retry_source_connection_id.value();
     if (!writer.WriteVarInt62(TransportParameters::kRetrySourceConnectionId) ||
@@ -921,7 +922,7 @@
     TransportParameters::TransportParameterId grease_id =
         static_cast<TransportParameters::TransportParameterId>(grease_id64);
     const size_t grease_length = random->RandUint64() % kMaxGreaseLength;
-    DCHECK_GE(kMaxGreaseLength, grease_length);
+    QUICHE_DCHECK_GE(kMaxGreaseLength, grease_length);
     char grease_contents[kMaxGreaseLength];
     random->RandBytes(grease_contents, grease_length);
     if (!writer.WriteVarInt62(grease_id) ||
@@ -1213,7 +1214,7 @@
         break;
     }
     if (!parse_success) {
-      DCHECK(!error_details->empty());
+      QUICHE_DCHECK(!error_details->empty());
       return false;
     }
     if (!value_reader.IsDoneReading()) {
@@ -1225,7 +1226,7 @@
   }
 
   if (!out->AreValid(error_details)) {
-    DCHECK(!error_details->empty());
+    QUICHE_DCHECK(!error_details->empty());
     return false;
   }
 
diff --git a/quic/core/frames/quic_ack_frame.cc b/quic/core/frames/quic_ack_frame.cc
index 4a578b1..7c112c2 100644
--- a/quic/core/frames/quic_ack_frame.cc
+++ b/quic/core/frames/quic_ack_frame.cc
@@ -20,7 +20,7 @@
 bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketNumber packet_number,
                       QuicPacketNumber peer_least_packet_awaiting_ack) {
-  DCHECK(packet_number.IsInitialized());
+  QUICHE_DCHECK(packet_number.IsInitialized());
   return (!peer_least_packet_awaiting_ack.IsInitialized() ||
           packet_number >= peer_least_packet_awaiting_ack) &&
          !ack_frame.packets.Contains(packet_number);
@@ -118,12 +118,12 @@
 }
 
 QuicPacketNumber PacketNumberQueue::Min() const {
-  DCHECK(!Empty());
+  QUICHE_DCHECK(!Empty());
   return packet_number_intervals_.begin()->min();
 }
 
 QuicPacketNumber PacketNumberQueue::Max() const {
-  DCHECK(!Empty());
+  QUICHE_DCHECK(!Empty());
   return packet_number_intervals_.rbegin()->max() - 1;
 }
 
@@ -156,7 +156,7 @@
 }
 
 QuicPacketCount PacketNumberQueue::LastIntervalLength() const {
-  DCHECK(!Empty());
+  QUICHE_DCHECK(!Empty());
   return packet_number_intervals_.rbegin()->Length();
 }
 
diff --git a/quic/core/frames/quic_frame.cc b/quic/core/frames/quic_frame.cc
index dd1163f..e54e254 100644
--- a/quic/core/frames/quic_frame.cc
+++ b/quic/core/frames/quic_frame.cc
@@ -96,7 +96,7 @@
       frame->type != STOP_WAITING_FRAME &&
       frame->type != STREAMS_BLOCKED_FRAME && frame->type != STREAM_FRAME &&
       frame->type != HANDSHAKE_DONE_FRAME) {
-    CHECK(!frame->delete_forbidden) << *frame;
+    QUICHE_CHECK(!frame->delete_forbidden) << *frame;
   }
 #endif  // QUIC_FRAME_DEBUG
   switch (frame->type) {
@@ -156,7 +156,7 @@
       delete frame->ack_frequency_frame;
       break;
     case NUM_FRAME_TYPES:
-      DCHECK(false) << "Cannot delete type: " << frame->type;
+      QUICHE_DCHECK(false) << "Cannot delete type: " << frame->type;
   }
 }
 
diff --git a/quic/core/frames/quic_new_connection_id_frame.cc b/quic/core/frames/quic_new_connection_id_frame.cc
index cea43aa..fa99dfe 100644
--- a/quic/core/frames/quic_new_connection_id_frame.cc
+++ b/quic/core/frames/quic_new_connection_id_frame.cc
@@ -17,7 +17,7 @@
       sequence_number(sequence_number),
       stateless_reset_token(stateless_reset_token),
       retire_prior_to(retire_prior_to) {
-  DCHECK(retire_prior_to <= sequence_number);
+  QUICHE_DCHECK(retire_prior_to <= sequence_number);
 }
 
 std::ostream& operator<<(std::ostream& os,
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index c017b16..887e0eb 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -4543,7 +4543,8 @@
   }
 
   void HoldNextPacket() {
-    DCHECK(packet_content_.empty()) << "There is already one packet on hold.";
+    QUICHE_DCHECK(packet_content_.empty())
+        << "There is already one packet on hold.";
     hold_next_packet_ = true;
   }
 
diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index 1aee09c..fe33a81 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -34,7 +34,7 @@
       remaining_push_id_length_(0),
       error_(QUIC_NO_ERROR),
       error_detail_("") {
-  DCHECK(visitor_);
+  QUICHE_DCHECK(visitor_);
 }
 
 HttpDecoder::~HttpDecoder() {}
@@ -84,16 +84,16 @@
 }
 
 QuicByteCount HttpDecoder::ProcessInput(const char* data, QuicByteCount len) {
-  DCHECK_EQ(QUIC_NO_ERROR, error_);
-  DCHECK_NE(STATE_ERROR, state_);
+  QUICHE_DCHECK_EQ(QUIC_NO_ERROR, error_);
+  QUICHE_DCHECK_NE(STATE_ERROR, state_);
 
   QuicDataReader reader(data, len);
   bool continue_processing = true;
   while (continue_processing &&
          (reader.BytesRemaining() != 0 || state_ == STATE_FINISH_PARSING)) {
     // |continue_processing| must have been set to false upon error.
-    DCHECK_EQ(QUIC_NO_ERROR, error_);
-    DCHECK_NE(STATE_ERROR, state_);
+    QUICHE_DCHECK_EQ(QUIC_NO_ERROR, error_);
+    QUICHE_DCHECK_NE(STATE_ERROR, state_);
 
     switch (state_) {
       case STATE_READING_FRAME_TYPE:
@@ -119,11 +119,11 @@
 }
 
 bool HttpDecoder::ReadFrameType(QuicDataReader* reader) {
-  DCHECK_NE(0u, reader->BytesRemaining());
+  QUICHE_DCHECK_NE(0u, reader->BytesRemaining());
   if (current_type_field_length_ == 0) {
     // A new frame is coming.
     current_type_field_length_ = reader->PeekVarInt62Length();
-    DCHECK_NE(0u, current_type_field_length_);
+    QUICHE_DCHECK_NE(0u, current_type_field_length_);
     if (current_type_field_length_ > reader->BytesRemaining()) {
       // Buffer a new type field.
       remaining_type_field_length_ = current_type_field_length_;
@@ -132,7 +132,7 @@
     }
     // The reader has all type data needed, so no need to buffer.
     bool success = reader->ReadVarInt62(&current_frame_type_);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   } else {
     // Buffer the existing type field.
     BufferFrameType(reader);
@@ -142,7 +142,7 @@
     }
     QuicDataReader type_reader(type_buffer_.data(), current_type_field_length_);
     bool success = type_reader.ReadVarInt62(&current_frame_type_);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   }
 
   // https://tools.ietf.org/html/draft-ietf-quic-http-31#section-7.2.8
@@ -165,11 +165,11 @@
 }
 
 bool HttpDecoder::ReadFrameLength(QuicDataReader* reader) {
-  DCHECK_NE(0u, reader->BytesRemaining());
+  QUICHE_DCHECK_NE(0u, reader->BytesRemaining());
   if (current_length_field_length_ == 0) {
     // A new frame is coming.
     current_length_field_length_ = reader->PeekVarInt62Length();
-    DCHECK_NE(0u, current_length_field_length_);
+    QUICHE_DCHECK_NE(0u, current_length_field_length_);
     if (current_length_field_length_ > reader->BytesRemaining()) {
       // Buffer a new length field.
       remaining_length_field_length_ = current_length_field_length_;
@@ -178,7 +178,7 @@
     }
     // The reader has all length data needed, so no need to buffer.
     bool success = reader->ReadVarInt62(&current_frame_length_);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   } else {
     // Buffer the existing length field.
     BufferFrameLength(reader);
@@ -189,7 +189,7 @@
     QuicDataReader length_reader(length_buffer_.data(),
                                  current_length_field_length_);
     bool success = length_reader.ReadVarInt62(&current_frame_length_);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   }
 
   if (current_frame_length_ > MaxFrameLength(current_frame_type_)) {
@@ -259,8 +259,8 @@
 }
 
 bool HttpDecoder::ReadFramePayload(QuicDataReader* reader) {
-  DCHECK_NE(0u, reader->BytesRemaining());
-  DCHECK_NE(0u, remaining_frame_length_);
+  QUICHE_DCHECK_NE(0u, reader->BytesRemaining());
+  QUICHE_DCHECK_NE(0u, remaining_frame_length_);
 
   bool continue_processing = true;
 
@@ -270,8 +270,8 @@
           remaining_frame_length_, reader->BytesRemaining());
       absl::string_view payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
-      DCHECK(success);
-      DCHECK(!payload.empty());
+      QUICHE_DCHECK(success);
+      QUICHE_DCHECK(!payload.empty());
       continue_processing = visitor_->OnDataFramePayload(payload);
       remaining_frame_length_ -= payload.length();
       break;
@@ -281,8 +281,8 @@
           remaining_frame_length_, reader->BytesRemaining());
       absl::string_view payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
-      DCHECK(success);
-      DCHECK(!payload.empty());
+      QUICHE_DCHECK(success);
+      QUICHE_DCHECK(!payload.empty());
       continue_processing = visitor_->OnHeadersFramePayload(payload);
       remaining_frame_length_ -= payload.length();
       break;
@@ -299,7 +299,7 @@
       PushId push_id;
       if (current_frame_length_ == remaining_frame_length_) {
         // A new Push Promise frame just arrived.
-        DCHECK_EQ(0u, current_push_id_length_);
+        QUICHE_DCHECK_EQ(0u, current_push_id_length_);
         current_push_id_length_ = reader->PeekVarInt62Length();
         if (current_push_id_length_ > remaining_frame_length_) {
           RaiseError(QUIC_HTTP_FRAME_ERROR,
@@ -308,13 +308,13 @@
         }
         if (current_push_id_length_ > reader->BytesRemaining()) {
           // Not all bytes of push id is present yet, buffer push id.
-          DCHECK_EQ(0u, remaining_push_id_length_);
+          QUICHE_DCHECK_EQ(0u, remaining_push_id_length_);
           remaining_push_id_length_ = current_push_id_length_;
           BufferPushId(reader);
           break;
         }
         bool success = reader->ReadVarInt62(&push_id);
-        DCHECK(success);
+        QUICHE_DCHECK(success);
         remaining_frame_length_ -= current_push_id_length_;
         if (!visitor_->OnPushPromiseFramePushId(
                 push_id, current_push_id_length_,
@@ -334,7 +334,7 @@
                                       current_push_id_length_);
 
         bool success = push_id_reader.ReadVarInt62(&push_id);
-        DCHECK(success);
+        QUICHE_DCHECK(success);
         if (!visitor_->OnPushPromiseFramePushId(
                 push_id, current_push_id_length_,
                 current_frame_length_ - current_push_id_length_)) {
@@ -346,7 +346,7 @@
       }
 
       // Read Push Promise headers.
-      DCHECK_LT(remaining_frame_length_, current_frame_length_);
+      QUICHE_DCHECK_LT(remaining_frame_length_, current_frame_length_);
       QuicByteCount bytes_to_read = std::min<QuicByteCount>(
           remaining_frame_length_, reader->BytesRemaining());
       if (bytes_to_read == 0) {
@@ -354,8 +354,8 @@
       }
       absl::string_view payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
-      DCHECK(success);
-      DCHECK(!payload.empty());
+      QUICHE_DCHECK(success);
+      QUICHE_DCHECK(!payload.empty());
       continue_processing = visitor_->OnPushPromiseFramePayload(payload);
       remaining_frame_length_ -= payload.length();
       break;
@@ -404,7 +404,7 @@
 }
 
 bool HttpDecoder::FinishParsing() {
-  DCHECK_EQ(0u, remaining_frame_length_);
+  QUICHE_DCHECK_EQ(0u, remaining_frame_length_);
 
   bool continue_processing = true;
 
@@ -528,8 +528,8 @@
       remaining_frame_length_, reader->BytesRemaining());
   absl::string_view payload;
   bool success = reader->ReadStringPiece(&payload, bytes_to_read);
-  DCHECK(success);
-  DCHECK(!payload.empty());
+  QUICHE_DCHECK(success);
+  QUICHE_DCHECK(!payload.empty());
   remaining_frame_length_ -= payload.length();
   return visitor_->OnUnknownFramePayload(payload);
 }
@@ -539,7 +539,7 @@
       remaining_frame_length_, reader->BytesRemaining());
   absl::string_view payload;
   bool success = reader->ReadStringPiece(&payload, bytes_to_read);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   remaining_frame_length_ -= payload.length();
   if (remaining_frame_length_ == 0) {
     state_ = STATE_READING_FRAME_TYPE;
@@ -558,7 +558,7 @@
   bool success = reader->ReadBytes(
       &(buffer_[0]) + current_frame_length_ - remaining_frame_length_,
       bytes_to_read);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   remaining_frame_length_ -= bytes_to_read;
 }
 
@@ -569,7 +569,7 @@
       reader->ReadBytes(length_buffer_.data() + current_length_field_length_ -
                             remaining_length_field_length_,
                         bytes_to_read);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   remaining_length_field_length_ -= bytes_to_read;
 }
 
@@ -580,19 +580,19 @@
       reader->ReadBytes(type_buffer_.data() + current_type_field_length_ -
                             remaining_type_field_length_,
                         bytes_to_read);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   remaining_type_field_length_ -= bytes_to_read;
 }
 
 void HttpDecoder::BufferPushId(QuicDataReader* reader) {
-  DCHECK_LE(remaining_push_id_length_, current_frame_length_);
+  QUICHE_DCHECK_LE(remaining_push_id_length_, current_frame_length_);
   QuicByteCount bytes_to_read = std::min<QuicByteCount>(
       reader->BytesRemaining(), remaining_push_id_length_);
   bool success =
       reader->ReadBytes(push_id_buffer_.data() + current_push_id_length_ -
                             remaining_push_id_length_,
                         bytes_to_read);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   remaining_push_id_length_ -= bytes_to_read;
   remaining_frame_length_ -= bytes_to_read;
 }
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 791d43c..1be5084 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -177,7 +177,7 @@
     QuicByteCount processed_bytes = ProcessInput(input_with_garbage_appended);
 
     // Guaranteed by HttpDecoder::ProcessInput() contract.
-    DCHECK_LE(processed_bytes, input_with_garbage_appended.size());
+    QUICHE_DCHECK_LE(processed_bytes, input_with_garbage_appended.size());
 
     // Caller should set up visitor to pause decoding
     // before HttpDecoder would read garbage.
diff --git a/quic/core/http/http_encoder.cc b/quic/core/http/http_encoder.cc
index 573bfad..fafe3b8 100644
--- a/quic/core/http/http_encoder.cc
+++ b/quic/core/http/http_encoder.cc
@@ -37,7 +37,7 @@
 QuicByteCount HttpEncoder::SerializeDataFrameHeader(
     QuicByteCount payload_length,
     std::unique_ptr<char[]>* output) {
-  DCHECK_NE(0u, payload_length);
+  QUICHE_DCHECK_NE(0u, payload_length);
   QuicByteCount header_length = QuicDataWriter::GetVarInt62Len(payload_length) +
                                 QuicDataWriter::GetVarInt62Len(
                                     static_cast<uint64_t>(HttpFrameType::DATA));
@@ -57,7 +57,7 @@
 QuicByteCount HttpEncoder::SerializeHeadersFrameHeader(
     QuicByteCount payload_length,
     std::unique_ptr<char[]>* output) {
-  DCHECK_NE(0u, payload_length);
+  QUICHE_DCHECK_NE(0u, payload_length);
   QuicByteCount header_length =
       QuicDataWriter::GetVarInt62Len(payload_length) +
       QuicDataWriter::GetVarInt62Len(
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index c87faa2..70e7f4a 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -45,7 +45,7 @@
   iovec iov;
   while (!reading_stopped() && decoder_.error() == QUIC_NO_ERROR &&
          sequencer()->GetReadableRegion(&iov)) {
-    DCHECK(!sequencer()->IsClosed());
+    QUICHE_DCHECK(!sequencer()->IsClosed());
 
     QuicByteCount processed_bytes = decoder_.ProcessInput(
         reinterpret_cast<const char*>(iov.iov_base), iov.iov_len);
@@ -57,7 +57,7 @@
 
     // The only reason QuicReceiveControlStream pauses HttpDecoder is an error,
     // in which case the connection would have already been closed.
-    DCHECK_EQ(iov.iov_len, processed_bytes);
+    QUICHE_DCHECK_EQ(iov.iov_len, processed_bytes);
   }
 }
 
@@ -270,7 +270,7 @@
 }
 
 bool QuicReceiveControlStream::OnAcceptChFrame(const AcceptChFrame& frame) {
-  DCHECK_EQ(Perspective::IS_CLIENT, spdy_session()->perspective());
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, spdy_session()->perspective());
 
   if (spdy_session()->debug_visitor()) {
     spdy_session()->debug_visitor()->OnAcceptChFrameReceived(frame);
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index 949b2bf..8334130 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -104,7 +104,7 @@
 }
 
 void QuicSendControlStream::SendMaxPushIdFrame(PushId max_push_id) {
-  DCHECK_EQ(Perspective::IS_CLIENT, session()->perspective());
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, session()->perspective());
   QuicConnection::ScopedPacketFlusher flusher(session()->connection());
   MaybeSendSettingsFrame();
 
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 1cb42aa..f9483fe 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -95,7 +95,7 @@
   }
 
   QuicSpdyStream* CreateOutgoingBidirectionalStream() override {
-    DCHECK(false);
+    QUICHE_DCHECK(false);
     return nullptr;
   }
 
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index e165de0..ba5b457 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -103,7 +103,7 @@
 }
 
 void QuicSpdyClientSession::CryptoConnect() {
-  DCHECK(flow_controller());
+  QUICHE_DCHECK(flow_controller());
   crypto_stream_->CryptoConnect();
 }
 
diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index 996af35..49f0198 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -155,7 +155,7 @@
   promised_by_id_[promised_id] = std::move(promised_owner);
   bool result = promised->OnPromiseHeaders(headers);
   if (result) {
-    DCHECK(promised_by_id_.find(promised_id) != promised_by_id_.end());
+    QUICHE_DCHECK(promised_by_id_.find(promised_id) != promised_by_id_.end());
   }
   return result;
 }
@@ -206,7 +206,7 @@
 void QuicSpdyClientSessionBase::ResetPromised(
     QuicStreamId id,
     QuicRstStreamErrorCode error_code) {
-  DCHECK(QuicUtils::IsServerInitiatedStreamId(transport_version(), id));
+  QUICHE_DCHECK(QuicUtils::IsServerInitiatedStreamId(transport_version(), id));
   ResetStream(id, error_code);
   if (!IsOpenStream(id) && !IsClosedStream(id)) {
     MaybeIncreaseLargestPeerStreamId(id);
diff --git a/quic/core/http/quic_spdy_client_stream.cc b/quic/core/http/quic_spdy_client_stream.cc
index 0d95dd3..931bfb3 100644
--- a/quic/core/http/quic_spdy_client_stream.cc
+++ b/quic/core/http/quic_spdy_client_stream.cc
@@ -48,7 +48,7 @@
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
 
-  DCHECK(headers_decompressed());
+  QUICHE_DCHECK(headers_decompressed());
   header_bytes_read_ += frame_len;
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &content_length_,
                                          &response_headers_)) {
diff --git a/quic/core/http/quic_spdy_server_stream_base.cc b/quic/core/http/quic_spdy_server_stream_base.cc
index efe730a..d6cbddf 100644
--- a/quic/core/http/quic_spdy_server_stream_base.cc
+++ b/quic/core/http/quic_spdy_server_stream_base.cc
@@ -25,7 +25,7 @@
       !rst_sent()) {
     // Early cancel the stream if it has stopped reading before receiving FIN
     // or RST.
-    DCHECK(fin_sent() || !session()->connection()->connected());
+    QUICHE_DCHECK(fin_sent() || !session()->connection()->connected());
     // Tell the peer to stop sending further data.
     QUIC_DVLOG(1) << " Server: Send QUIC_STREAM_NO_ERROR on stream " << id();
     if (session()->split_up_send_rst()) {
@@ -41,7 +41,7 @@
 void QuicSpdyServerStreamBase::StopReading() {
   if (!fin_received() && !rst_received() && write_side_closed() &&
       !rst_sent()) {
-    DCHECK(fin_sent());
+    QUICHE_DCHECK(fin_sent());
     // Tell the peer to stop sending further data.
     QUIC_DVLOG(1) << " Server: Send QUIC_STREAM_NO_ERROR on stream " << id();
     if (session()->split_up_send_rst()) {
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 8026ac2..5374044 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -180,12 +180,12 @@
 
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId /* stream_id */) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     return &header_list_;
   }
 
   void OnHeaderFrameEnd(SpdyStreamId /* stream_id */) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
 
     LogHeaderCompressionRatioHistogram(
         /* using_qpack = */ false,
@@ -201,7 +201,7 @@
   void OnStreamFrameData(SpdyStreamId /*stream_id*/,
                          const char* /*data*/,
                          size_t /*len*/) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -290,7 +290,7 @@
   void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
                          size_t /*length*/,
                          bool /*fin*/) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -302,12 +302,12 @@
   }
 
   void OnSetting(SpdySettingsId id, uint32_t value) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     session_->OnSetting(id, value);
   }
 
   void OnSettingsEnd() override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
   }
 
   void OnPing(SpdyPingId /*unique_id*/, bool /*is_ack*/) override {
@@ -357,7 +357,7 @@
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      bool /*end*/) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     if (session_->perspective() != Perspective::IS_CLIENT) {
       CloseConnection("PUSH_PROMISE not supported.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
@@ -375,7 +375,7 @@
                   SpdyStreamId /* parent_id */,
                   int weight,
                   bool /* exclusive */) override {
-    DCHECK(!VersionUsesHttp3(session_->transport_version()));
+    QUICHE_DCHECK(!VersionUsesHttp3(session_->transport_version()));
     if (!session_->IsConnected()) {
       return;
     }
@@ -507,12 +507,12 @@
           QuicUtils::GetHeadersStreamId(transport_version()));
     } else {
       QuicStreamId headers_stream_id = GetNextOutgoingBidirectionalStreamId();
-      DCHECK_EQ(headers_stream_id,
-                QuicUtils::GetHeadersStreamId(transport_version()));
+      QUICHE_DCHECK_EQ(headers_stream_id,
+                       QuicUtils::GetHeadersStreamId(transport_version()));
     }
     auto headers_stream = std::make_unique<QuicHeadersStream>((this));
-    DCHECK_EQ(QuicUtils::GetHeadersStreamId(transport_version()),
-              headers_stream->id());
+    QUICHE_DCHECK_EQ(QuicUtils::GetHeadersStreamId(transport_version()),
+                     headers_stream->id());
 
     headers_stream_ = headers_stream.get();
     ActivateStream(std::move(headers_stream));
@@ -542,7 +542,7 @@
 
 void QuicSpdySession::OnDecoderStreamError(QuicErrorCode error_code,
                                            absl::string_view error_message) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   CloseConnectionWithDetails(
       error_code, absl::StrCat("Decoder stream error: ", error_message));
@@ -550,7 +550,7 @@
 
 void QuicSpdySession::OnEncoderStreamError(QuicErrorCode error_code,
                                            absl::string_view error_message) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   CloseConnectionWithDetails(
       error_code, absl::StrCat("Encoder stream error: ", error_message));
@@ -690,7 +690,7 @@
     bool fin,
     const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
 
   return WriteHeadersOnHeadersStreamImpl(
       id, std::move(headers), fin,
@@ -703,7 +703,7 @@
                                       QuicStreamId parent_stream_id,
                                       int weight,
                                       bool exclusive) {
-  DCHECK(!VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
   SpdyPriorityIR priority_frame(id, parent_stream_id, weight, exclusive);
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(priority_frame));
   headers_stream()->WriteOrBufferData(
@@ -713,7 +713,7 @@
 
 void QuicSpdySession::WriteHttp3PriorityUpdate(
     const PriorityUpdateFrame& priority_update) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   send_control_stream_->WritePriorityUpdate(priority_update);
 }
@@ -765,7 +765,7 @@
   // goaway.
   if (perspective() == Perspective::IS_SERVER &&
       frame.stream_count >= QuicUtils::GetMaxStreamCount()) {
-    DCHECK_EQ(frame.stream_count, QuicUtils::GetMaxStreamCount());
+    QUICHE_DCHECK_EQ(frame.stream_count, QuicUtils::GetMaxStreamCount());
     SendHttp3GoAway(QUIC_PEER_GOING_AWAY, "stream count too large");
   }
   return true;
@@ -773,8 +773,8 @@
 
 void QuicSpdySession::SendHttp3GoAway(QuicErrorCode error_code,
                                       const std::string& reason) {
-  DCHECK_EQ(perspective(), Perspective::IS_SERVER);
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(perspective(), Perspective::IS_SERVER);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   if (GetQuicReloadableFlag(quic_encrypted_goaway)) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_encrypted_goaway, 2, 2);
     if (!IsEncryptionEstablished()) {
@@ -835,8 +835,8 @@
     return;
   }
 
-  DCHECK_EQ(perspective(), Perspective::IS_SERVER);
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(perspective(), Perspective::IS_SERVER);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   QuicStreamCount advertised_max_incoming_bidirectional_streams =
       GetAdvertisedMaxIncomingBidirectionalStreams();
   const QuicStreamId stream_id =
@@ -915,13 +915,13 @@
 }
 
 QpackEncoder* QuicSpdySession::qpack_encoder() {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   return qpack_encoder_.get();
 }
 
 QpackDecoder* QuicSpdySession::qpack_decoder() {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   return qpack_decoder_.get();
 }
@@ -964,7 +964,8 @@
 
 // True if there are open HTTP requests.
 bool QuicSpdySession::ShouldKeepConnectionAlive() const {
-  DCHECK(VersionUsesHttp3(transport_version()) || 0u == pending_streams_size());
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()) ||
+                0u == pending_streams_size());
   return GetNumActiveStreams() + pending_streams_size() > 0;
 }
 
@@ -983,7 +984,7 @@
     int weight,
     bool exclusive,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
 
   const QuicByteCount uncompressed_size = headers.TotalBytesUsed();
   SpdyHeadersIR headers_frame(id, std::move(headers));
@@ -1027,8 +1028,8 @@
 }
 
 bool QuicSpdySession::ResumeApplicationState(ApplicationState* cached_state) {
-  DCHECK_EQ(perspective(), Perspective::IS_CLIENT);
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(perspective(), Perspective::IS_CLIENT);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   SettingsFrame out;
   if (!HttpDecoder::DecodeSettings(
@@ -1067,7 +1068,7 @@
 }
 
 bool QuicSpdySession::OnSettingsFrame(const SettingsFrame& frame) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSettingsFrameReceived(frame);
   }
@@ -1251,18 +1252,20 @@
       return;
     }
   }
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()), stream_id_);
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
-            promised_stream_id_);
+  QUICHE_DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
+                   stream_id_);
+  QUICHE_DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
+                   promised_stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
 }
 
 void QuicSpdySession::OnPushPromise(SpdyStreamId stream_id,
                                     SpdyStreamId promised_stream_id) {
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()), stream_id_);
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
-            promised_stream_id_);
+  QUICHE_DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
+                   stream_id_);
+  QUICHE_DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
+                   promised_stream_id_);
   stream_id_ = stream_id;
   promised_stream_id_ = promised_stream_id;
 }
@@ -1284,8 +1287,8 @@
                 << ": " << header_list.DebugString();
   // This code path is only executed for push promise in IETF QUIC.
   if (VersionUsesHttp3(transport_version())) {
-    DCHECK(promised_stream_id_ !=
-           QuicUtils::GetInvalidStreamId(transport_version()));
+    QUICHE_DCHECK(promised_stream_id_ !=
+                  QuicUtils::GetInvalidStreamId(transport_version()));
   }
   if (promised_stream_id_ ==
       QuicUtils::GetInvalidStreamId(transport_version())) {
@@ -1330,8 +1333,8 @@
 }
 
 bool QuicSpdySession::ProcessPendingStream(PendingStream* pending) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(connection()->connected());
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(connection()->connected());
   struct iovec iov;
   if (!pending->sequencer()->GetReadableRegion(&iov)) {
     // The first byte hasn't been received yet.
@@ -1417,7 +1420,7 @@
 }
 
 void QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams() {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   if (!send_control_stream_ && CanOpenNextOutgoingUnidirectionalStream()) {
     auto send_control = std::make_unique<QuicSendControlStream>(
         GetNextOutgoingUnidirectionalStreamId(), this, settings_);
@@ -1463,7 +1466,7 @@
     return;
   }
 
-  DCHECK_EQ(perspective(), Perspective::IS_SERVER);
+  QUICHE_DCHECK_EQ(perspective(), Perspective::IS_SERVER);
 
   QUIC_CODE_COUNT(quic_send_goaway_with_connection_close);
 
@@ -1505,10 +1508,10 @@
 }
 
 void QuicSpdySession::SetMaxPushId(PushId max_push_id) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective());
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective());
   if (max_push_id_.has_value()) {
-    DCHECK_GE(max_push_id, max_push_id_.value());
+    QUICHE_DCHECK_GE(max_push_id, max_push_id_.value());
   }
 
   if (!max_push_id_.has_value() && max_push_id == 0) {
@@ -1537,8 +1540,8 @@
 }
 
 bool QuicSpdySession::OnMaxPushIdFrame(PushId max_push_id) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK_EQ(Perspective::IS_SERVER, perspective());
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective());
 
   if (max_push_id_.has_value()) {
     QUIC_DVLOG(1) << "Setting max_push_id to:  " << max_push_id
@@ -1569,16 +1572,16 @@
 }
 
 void QuicSpdySession::SendMaxPushId() {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective());
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective());
 
   send_control_stream_->SendMaxPushIdFrame(max_push_id_.value());
   http3_max_push_id_sent_ = true;
 }
 
 void QuicSpdySession::EnableServerPush() {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK_EQ(perspective(), Perspective::IS_SERVER);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK_EQ(perspective(), Perspective::IS_SERVER);
 
   ietf_server_push_enabled_ = true;
 }
@@ -1596,7 +1599,7 @@
 }
 
 bool QuicSpdySession::CanCreatePushStreamWithId(PushId push_id) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   return ietf_server_push_enabled_ && max_push_id_.has_value() &&
          max_push_id_.value() >= push_id;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 89d06d4..db263b0 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -346,7 +346,7 @@
   }
 
   QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
-    DCHECK(writev_consumes_all_data_);
+    QUICHE_DCHECK(writev_consumes_all_data_);
     return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
                       GetEncryptionLevelToSendApplicationData());
   }
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 4e84d9b..aa5f7bf 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -76,7 +76,7 @@
   }
 
   bool OnDataFramePayload(absl::string_view payload) override {
-    DCHECK(!payload.empty());
+    QUICHE_DCHECK(!payload.empty());
     return stream_->OnDataFramePayload(payload);
   }
 
@@ -92,7 +92,7 @@
   }
 
   bool OnHeadersFramePayload(absl::string_view payload) override {
-    DCHECK(!payload.empty());
+    QUICHE_DCHECK(!payload.empty());
     if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
       return false;
@@ -128,7 +128,7 @@
   }
 
   bool OnPushPromiseFramePayload(absl::string_view payload) override {
-    DCHECK(!payload.empty());
+    QUICHE_DCHECK(!payload.empty());
     if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
@@ -211,10 +211,10 @@
       is_decoder_processing_input_(false),
       ack_listener_(nullptr),
       last_sent_urgency_(kDefaultUrgency) {
-  DCHECK_EQ(session()->connection(), spdy_session->connection());
-  DCHECK_EQ(transport_version(), spdy_session->transport_version());
-  DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
-  DCHECK_EQ(0u, sequencer()->NumBytesConsumed());
+  QUICHE_DCHECK_EQ(session()->connection(), spdy_session->connection());
+  QUICHE_DCHECK_EQ(transport_version(), spdy_session->transport_version());
+  QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
+  QUICHE_DCHECK_EQ(0u, sequencer()->NumBytesConsumed());
   // If headers are sent on the headers stream, then do not receive any
   // callbacks from the sequencer until headers are complete.
   if (!VersionUsesHttp3(transport_version())) {
@@ -247,9 +247,9 @@
       is_decoder_processing_input_(false),
       ack_listener_(nullptr),
       last_sent_urgency_(kDefaultUrgency) {
-  DCHECK_EQ(session()->connection(), spdy_session->connection());
-  DCHECK_EQ(transport_version(), spdy_session->transport_version());
-  DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id()));
+  QUICHE_DCHECK_EQ(session()->connection(), spdy_session->connection());
+  QUICHE_DCHECK_EQ(transport_version(), spdy_session->transport_version());
+  QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id()));
   // If headers are sent on the headers stream, then do not receive any
   // callbacks from the sequencer until headers are complete.
   if (!VersionUsesHttp3(transport_version())) {
@@ -373,7 +373,7 @@
 }
 
 void QuicSpdyStream::WritePushPromise(const PushPromiseFrame& frame) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   std::unique_ptr<char[]> push_promise_frame_with_id;
   const size_t push_promise_frame_length =
       HttpEncoder::SerializePushPromiseFrameWithOnlyPushId(
@@ -453,7 +453,7 @@
 }
 
 size_t QuicSpdyStream::Readv(const struct iovec* iov, size_t iov_len) {
-  DCHECK(FinishedReadingHeaders());
+  QUICHE_DCHECK(FinishedReadingHeaders());
   if (!VersionUsesHttp3(transport_version())) {
     return sequencer()->Readv(iov, iov_len);
   }
@@ -464,7 +464,7 @@
 }
 
 int QuicSpdyStream::GetReadableRegions(iovec* iov, size_t iov_len) const {
-  DCHECK(FinishedReadingHeaders());
+  QUICHE_DCHECK(FinishedReadingHeaders());
   if (!VersionUsesHttp3(transport_version())) {
     return sequencer()->GetReadableRegions(iov, iov_len);
   }
@@ -472,7 +472,7 @@
 }
 
 void QuicSpdyStream::MarkConsumed(size_t num_bytes) {
-  DCHECK(FinishedReadingHeaders());
+  QUICHE_DCHECK(FinishedReadingHeaders());
   if (!VersionUsesHttp3(transport_version())) {
     sequencer()->MarkConsumed(num_bytes);
     return;
@@ -532,7 +532,8 @@
 
 void QuicSpdyStream::OnStreamHeadersPriority(
     const spdy::SpdyStreamPrecedence& precedence) {
-  DCHECK_EQ(Perspective::IS_SERVER, session()->connection()->perspective());
+  QUICHE_DCHECK_EQ(Perspective::IS_SERVER,
+                   session()->connection()->perspective());
   SetPriority(precedence);
 }
 
@@ -679,7 +680,7 @@
     size_t /*frame_len*/,
     const QuicHeaderList& header_list) {
   // TODO(b/134706391): remove |fin| argument.
-  DCHECK(!trailers_decompressed_);
+  QUICHE_DCHECK(!trailers_decompressed_);
   if (!VersionUsesHttp3(transport_version()) && fin_received()) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Received Trailers after FIN, on stream: " << id();
@@ -718,7 +719,8 @@
 
 void QuicSpdyStream::OnPriorityFrame(
     const spdy::SpdyStreamPrecedence& precedence) {
-  DCHECK_EQ(Perspective::IS_SERVER, session()->connection()->perspective());
+  QUICHE_DCHECK_EQ(Perspective::IS_SERVER,
+                   session()->connection()->perspective());
   SetPriority(precedence);
 }
 
@@ -761,7 +763,7 @@
 void QuicSpdyStream::OnDataAvailable() {
   if (!VersionUsesHttp3(transport_version())) {
     // Sequencer must be blocked until headers are consumed.
-    DCHECK(FinishedReadingHeaders());
+    QUICHE_DCHECK(FinishedReadingHeaders());
   }
 
   if (!VersionUsesHttp3(transport_version())) {
@@ -781,12 +783,12 @@
   iovec iov;
   while (session()->connection()->connected() && !reading_stopped() &&
          decoder_.error() == QUIC_NO_ERROR) {
-    DCHECK_GE(sequencer_offset_, sequencer()->NumBytesConsumed());
+    QUICHE_DCHECK_GE(sequencer_offset_, sequencer()->NumBytesConsumed());
     if (!sequencer()->PeekRegion(sequencer_offset_, &iov)) {
       break;
     }
 
-    DCHECK(!sequencer()->IsClosed());
+    QUICHE_DCHECK(!sequencer()->IsClosed());
     is_decoder_processing_input_ = true;
     QuicByteCount processed_bytes = decoder_.ProcessInput(
         reinterpret_cast<const char*>(iov.iov_base), iov.iov_len);
@@ -877,7 +879,7 @@
 
 bool QuicSpdyStream::OnDataFrameStart(QuicByteCount header_length,
                                       QuicByteCount payload_length) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   if (spdy_session_->debug_visitor()) {
     spdy_session_->debug_visitor()->OnDataFrameReceived(id(), payload_length);
@@ -896,7 +898,7 @@
 }
 
 bool QuicSpdyStream::OnDataFramePayload(absl::string_view payload) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   body_manager_.OnBody(payload);
 
@@ -904,7 +906,7 @@
 }
 
 bool QuicSpdyStream::OnDataFrameEnd() {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   QUIC_DVLOG(1) << ENDPOINT
                 << "Reaches the end of a data frame. Total bytes received are "
@@ -924,7 +926,7 @@
 
   const QuicByteCount newly_acked_header_length =
       GetNumFrameHeadersInInterval(offset, data_length);
-  DCHECK_LE(newly_acked_header_length, *newly_acked_length);
+  QUICHE_DCHECK_LE(newly_acked_header_length, *newly_acked_length);
   unacked_frame_headers_offsets_.Difference(offset, offset + data_length);
   if (ack_listener_ != nullptr && new_data_acked) {
     ack_listener_->OnPacketAcked(
@@ -941,7 +943,7 @@
 
   const QuicByteCount retransmitted_header_length =
       GetNumFrameHeadersInInterval(offset, data_length);
-  DCHECK_LE(retransmitted_header_length, data_length);
+  QUICHE_DCHECK_LE(retransmitted_header_length, data_length);
 
   if (ack_listener_ != nullptr) {
     ack_listener_->OnPacketRetransmitted(data_length -
@@ -963,8 +965,8 @@
 
 bool QuicSpdyStream::OnHeadersFrameStart(QuicByteCount header_length,
                                          QuicByteCount payload_length) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(!qpack_decoded_headers_accumulator_);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!qpack_decoded_headers_accumulator_);
 
   if (spdy_session_->debug_visitor()) {
     spdy_session_->debug_visitor()->OnHeadersFrameReceived(id(),
@@ -991,8 +993,8 @@
 }
 
 bool QuicSpdyStream::OnHeadersFramePayload(absl::string_view payload) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(qpack_decoded_headers_accumulator_);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(qpack_decoded_headers_accumulator_);
 
   qpack_decoded_headers_accumulator_->Decode(payload);
 
@@ -1006,8 +1008,8 @@
 }
 
 bool QuicSpdyStream::OnHeadersFrameEnd() {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(qpack_decoded_headers_accumulator_);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(qpack_decoded_headers_accumulator_);
 
   qpack_decoded_headers_accumulator_->EndHeaderBlock();
 
@@ -1022,8 +1024,8 @@
 }
 
 bool QuicSpdyStream::OnPushPromiseFrameStart(QuicByteCount header_length) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(!qpack_decoded_headers_accumulator_);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!qpack_decoded_headers_accumulator_);
 
   sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
 
@@ -1034,8 +1036,8 @@
     PushId push_id,
     QuicByteCount push_id_length,
     QuicByteCount header_block_length) {
-  DCHECK(VersionUsesHttp3(transport_version()));
-  DCHECK(!qpack_decoded_headers_accumulator_);
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!qpack_decoded_headers_accumulator_);
 
   if (spdy_session_->debug_visitor()) {
     spdy_session_->debug_visitor()->OnPushPromiseFrameReceived(
@@ -1060,7 +1062,7 @@
 }
 
 bool QuicSpdyStream::OnPushPromiseFrameEnd() {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
 
   return OnHeadersFrameEnd();
 }
diff --git a/quic/core/http/quic_spdy_stream_body_manager.cc b/quic/core/http/quic_spdy_stream_body_manager.cc
index efecca5..1d40e03 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager.cc
@@ -15,7 +15,7 @@
     : total_body_bytes_received_(0) {}
 
 size_t QuicSpdyStreamBodyManager::OnNonBody(QuicByteCount length) {
-  DCHECK_NE(0u, length);
+  QUICHE_DCHECK_NE(0u, length);
 
   if (fragments_.empty()) {
     // Non-body bytes can be consumed immediately, because all previously
@@ -29,7 +29,7 @@
 }
 
 void QuicSpdyStreamBodyManager::OnBody(absl::string_view body) {
-  DCHECK(!body.empty());
+  QUICHE_DCHECK(!body.empty());
 
   fragments_.push_back({body, 0});
   total_body_bytes_received_ += body.length();
@@ -66,8 +66,8 @@
 }
 
 int QuicSpdyStreamBodyManager::PeekBody(iovec* iov, size_t iov_len) const {
-  DCHECK(iov);
-  DCHECK_GT(iov_len, 0u);
+  QUICHE_DCHECK(iov);
+  QUICHE_DCHECK_GT(iov_len, 0u);
 
   // TODO(bnc): Is this really necessary?
   if (fragments_.empty()) {
diff --git a/quic/core/http/quic_spdy_stream_body_manager_test.cc b/quic/core/http/quic_spdy_stream_body_manager_test.cc
index 096982f..90e50d4 100644
--- a/quic/core/http/quic_spdy_stream_body_manager_test.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager_test.cc
@@ -260,7 +260,7 @@
       std::vector<iovec> iovecs;
       size_t offset = 0;
       for (size_t iov_length : iov_lengths[call_index]) {
-        CHECK(offset + iov_length <= buffer.size());
+        QUICHE_CHECK(offset + iov_length <= buffer.size());
         iovecs.push_back({&buffer[offset], iov_length});
         offset += iov_length;
       }
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index d7aa6e7..14f3eab 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -479,7 +479,7 @@
     // Even though integers can be encoded with different lengths,
     // QuicDataWriter is expected to produce an encoding in Write*() of length
     // promised in GetVarInt62Len().
-    DCHECK_EQ(length, writer.length());
+    QUICHE_DCHECK_EQ(length, writer.length());
 
     return frame;
   }
diff --git a/quic/core/legacy_quic_stream_id_manager.cc b/quic/core/legacy_quic_stream_id_manager.cc
index c9a0f9b..36974af 100644
--- a/quic/core/legacy_quic_stream_id_manager.cc
+++ b/quic/core/legacy_quic_stream_id_manager.cc
@@ -36,7 +36,7 @@
 LegacyQuicStreamIdManager::~LegacyQuicStreamIdManager() {}
 
 bool LegacyQuicStreamIdManager::CanOpenNextOutgoingStream() const {
-  DCHECK_LE(num_open_outgoing_streams_, max_open_outgoing_streams_);
+  QUICHE_DCHECK_LE(num_open_outgoing_streams_, max_open_outgoing_streams_);
   QUIC_DLOG_IF(INFO, num_open_outgoing_streams_ == max_open_outgoing_streams_)
       << "Failed to create a new outgoing stream. "
       << "Already " << num_open_outgoing_streams_ << " open.";
diff --git a/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
index 23e0523..9c51f61 100644
--- a/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
@@ -58,7 +58,7 @@
   void OnDecodingCompleted() override {
     // Will delete |this|.
     size_t result = processing_decoders_->erase(stream_id_);
-    CHECK_EQ(1u, result);
+    QUICHE_CHECK_EQ(1u, result);
   }
 
   void OnDecodingErrorDetected(absl::string_view /*error_message*/) override {
diff --git a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index ab11210..4e4ebc4 100644
--- a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -37,8 +37,8 @@
 
   ~EncodingEndpoint() {
     // Every reference should be acknowledged.
-    CHECK_EQ(std::numeric_limits<uint64_t>::max(),
-             QpackEncoderPeer::smallest_blocking_index(&encoder_));
+    QUICHE_CHECK_EQ(std::numeric_limits<uint64_t>::max(),
+                    QpackEncoderPeer::smallest_blocking_index(&encoder_));
   }
 
   void set_qpack_stream_sender_delegate(QpackStreamSenderDelegate* delegate) {
@@ -67,7 +67,8 @@
 
     void OnDecoderStreamError(QuicErrorCode error_code,
                               absl::string_view error_message) override {
-      CHECK(false) << QuicErrorCodeToString(error_code) << " " << error_message;
+      QUICHE_CHECK(false) << QuicErrorCodeToString(error_code) << " "
+                          << error_message;
     }
   };
 
@@ -102,7 +103,7 @@
                                 QuicFuzzedDataProvider* provider)
       : visitor_(visitor), provider_(provider) {}
 
-  ~DelayedHeaderBlockTransmitter() { CHECK(header_blocks_.empty()); }
+  ~DelayedHeaderBlockTransmitter() { QUICHE_CHECK(header_blocks_.empty()); }
 
   // Enqueues |encoded_header_block| for delayed transmission.
   void SendEncodedHeaderBlock(QuicStreamId stream_id,
@@ -111,7 +112,7 @@
     if (it == header_blocks_.end() || it->first != stream_id) {
       it = header_blocks_.insert(it, {stream_id, {}});
     }
-    CHECK_EQ(stream_id, it->first);
+    QUICHE_CHECK_EQ(stream_id, it->first);
     it->second.push(HeaderBlock(std::move(encoded_header_block)));
   }
 
@@ -140,13 +141,13 @@
       visitor_->OnHeaderBlockStart(stream_id);
     }
 
-    DCHECK_NE(0u, header_block.RemainingLength());
+    QUICHE_DCHECK_NE(0u, header_block.RemainingLength());
 
     size_t length = provider_->ConsumeIntegralInRange<size_t>(
         1, header_block.RemainingLength());
     visitor_->OnHeaderBlockFragment(stream_id, header_block.Consume(length));
 
-    DCHECK_NE(0u, header_block.ConsumedLength());
+    QUICHE_DCHECK_NE(0u, header_block.ConsumedLength());
 
     if (header_block.RemainingLength() == 0) {
       visitor_->OnHeaderBlockEnd(stream_id);
@@ -170,20 +171,20 @@
       HeaderBlock& header_block = header_block_queue.front();
 
       if (header_block.ConsumedLength() == 0) {
-        CHECK(!visitor_->IsDecodingInProgressOnStream(stream_id));
+        QUICHE_CHECK(!visitor_->IsDecodingInProgressOnStream(stream_id));
         visitor_->OnHeaderBlockStart(stream_id);
       }
 
-      DCHECK_NE(0u, header_block.RemainingLength());
+      QUICHE_DCHECK_NE(0u, header_block.RemainingLength());
 
       visitor_->OnHeaderBlockFragment(stream_id,
                                       header_block.ConsumeRemaining());
 
-      DCHECK_NE(0u, header_block.ConsumedLength());
-      DCHECK_EQ(0u, header_block.RemainingLength());
+      QUICHE_DCHECK_NE(0u, header_block.ConsumedLength());
+      QUICHE_DCHECK_EQ(0u, header_block.RemainingLength());
 
       visitor_->OnHeaderBlockEnd(stream_id);
-      CHECK(!visitor_->IsDecodingInProgressOnStream(stream_id));
+      QUICHE_CHECK(!visitor_->IsDecodingInProgressOnStream(stream_id));
 
       header_block_queue.pop();
       if (header_block_queue.empty()) {
@@ -199,7 +200,7 @@
     explicit HeaderBlock(std::string data)
         : data_(std::move(data)), offset_(0) {
       // Valid QPACK header block cannot be empty.
-      DCHECK(!data_.empty());
+      QUICHE_DCHECK(!data_.empty());
     }
 
     size_t ConsumedLength() const { return offset_; }
@@ -207,8 +208,8 @@
     size_t RemainingLength() const { return data_.length() - offset_; }
 
     absl::string_view Consume(size_t length) {
-      DCHECK_NE(0u, length);
-      DCHECK_LE(length, RemainingLength());
+      QUICHE_DCHECK_NE(0u, length);
+      QUICHE_DCHECK_LE(length, RemainingLength());
 
       absl::string_view consumed = absl::string_view(&data_[offset_], length);
       offset_ += length;
@@ -270,15 +271,15 @@
   void OnHeadersDecoded(QuicHeaderList headers,
                         bool header_list_size_limit_exceeded) override {
     // Verify headers.
-    CHECK(!header_list_size_limit_exceeded);
-    CHECK(expected_header_list_ == headers);
+    QUICHE_CHECK(!header_list_size_limit_exceeded);
+    QUICHE_CHECK(expected_header_list_ == headers);
 
     // Might destroy |this|.
     visitor_->OnHeaderBlockDecoded(stream_id_);
   }
 
   void OnHeaderDecodingError(absl::string_view error_message) override {
-    CHECK(false) << error_message;
+    QUICHE_CHECK(false) << error_message;
   }
 
   void Decode(absl::string_view data) { accumulator_.Decode(data); }
@@ -306,8 +307,8 @@
 
   ~DecodingEndpoint() override {
     // All decoding must have been completed.
-    CHECK(expected_header_lists_.empty());
-    CHECK(verifying_decoders_.empty());
+    QUICHE_CHECK(expected_header_lists_.empty());
+    QUICHE_CHECK(verifying_decoders_.empty());
   }
 
   void set_qpack_stream_sender_delegate(QpackStreamSenderDelegate* delegate) {
@@ -324,14 +325,14 @@
     if (it == expected_header_lists_.end() || it->first != stream_id) {
       it = expected_header_lists_.insert(it, {stream_id, {}});
     }
-    CHECK_EQ(stream_id, it->first);
+    QUICHE_CHECK_EQ(stream_id, it->first);
     it->second.push(std::move(expected_header_list));
   }
 
   // VerifyingDecoder::Visitor implementation.
   void OnHeaderBlockDecoded(QuicStreamId stream_id) override {
     auto result = verifying_decoders_.erase(stream_id);
-    CHECK_EQ(1u, result);
+    QUICHE_CHECK_EQ(1u, result);
   }
 
   // DelayedHeaderBlockTransmitter::Visitor implementation.
@@ -340,9 +341,9 @@
   }
 
   void OnHeaderBlockStart(QuicStreamId stream_id) override {
-    CHECK(!IsDecodingInProgressOnStream(stream_id));
+    QUICHE_CHECK(!IsDecodingInProgressOnStream(stream_id));
     auto it = expected_header_lists_.find(stream_id);
-    CHECK(it != expected_header_lists_.end());
+    QUICHE_CHECK(it != expected_header_lists_.end());
 
     auto& header_list_queue = it->second;
     QuicHeaderList expected_header_list = std::move(header_list_queue.front());
@@ -356,19 +357,19 @@
         stream_id, this, &decoder_, std::move(expected_header_list));
     auto result =
         verifying_decoders_.insert({stream_id, std::move(verifying_decoder)});
-    CHECK(result.second);
+    QUICHE_CHECK(result.second);
   }
 
   void OnHeaderBlockFragment(QuicStreamId stream_id,
                              absl::string_view data) override {
     auto it = verifying_decoders_.find(stream_id);
-    CHECK(it != verifying_decoders_.end());
+    QUICHE_CHECK(it != verifying_decoders_.end());
     it->second->Decode(data);
   }
 
   void OnHeaderBlockEnd(QuicStreamId stream_id) override {
     auto it = verifying_decoders_.find(stream_id);
-    CHECK(it != verifying_decoders_.end());
+    QUICHE_CHECK(it != verifying_decoders_.end());
     it->second->EndHeaderBlock();
   }
 
@@ -381,7 +382,8 @@
 
     void OnEncoderStreamError(QuicErrorCode error_code,
                               absl::string_view error_message) override {
-      CHECK(false) << QuicErrorCodeToString(error_code) << " " << error_message;
+      QUICHE_CHECK(false) << QuicErrorCodeToString(error_code) << " "
+                          << error_message;
     }
   };
 
@@ -407,7 +409,7 @@
                                QuicFuzzedDataProvider* provider)
       : receiver_(receiver), provider_(provider) {}
 
-  ~DelayedStreamDataTransmitter() { CHECK(stream_data.empty()); }
+  ~DelayedStreamDataTransmitter() { QUICHE_CHECK(stream_data.empty()); }
 
   // QpackStreamSenderDelegate implementation.
   void WriteStreamData(absl::string_view data) override {
diff --git a/quic/core/qpack/qpack_blocking_manager.cc b/quic/core/qpack/qpack_blocking_manager.cc
index 21f604e..3b03710 100644
--- a/quic/core/qpack/qpack_blocking_manager.cc
+++ b/quic/core/qpack/qpack_blocking_manager.cc
@@ -17,10 +17,10 @@
     return false;
   }
 
-  DCHECK(!it->second.empty());
+  QUICHE_DCHECK(!it->second.empty());
 
   const IndexSet& indices = it->second.front();
-  DCHECK(!indices.empty());
+  QUICHE_DCHECK(!indices.empty());
 
   const uint64_t required_index_count = RequiredInsertCount(indices);
   if (known_received_count_ < required_index_count) {
@@ -62,7 +62,7 @@
 
 void QpackBlockingManager::OnHeaderBlockSent(QuicStreamId stream_id,
                                              IndexSet indices) {
-  DCHECK(!indices.empty());
+  QUICHE_DCHECK(!indices.empty());
 
   IncreaseReferenceCounts(indices);
   header_blocks_[stream_id].push_back(std::move(indices));
@@ -145,8 +145,8 @@
 void QpackBlockingManager::DecreaseReferenceCounts(const IndexSet& indices) {
   for (const uint64_t index : indices) {
     auto it = entry_reference_counts_.find(index);
-    DCHECK(it != entry_reference_counts_.end());
-    DCHECK_NE(0u, it->second);
+    QUICHE_DCHECK(it != entry_reference_counts_.end());
+    QUICHE_DCHECK_NE(0u, it->second);
 
     if (it->second == 1) {
       entry_reference_counts_.erase(it);
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.cc b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
index 60be426..f5ddeee 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
@@ -29,7 +29,7 @@
 
 void QpackDecodedHeadersAccumulator::OnHeaderDecoded(absl::string_view name,
                                                      absl::string_view value) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   uncompressed_header_bytes_without_overhead_ += name.size() + value.size();
 
@@ -49,8 +49,8 @@
 }
 
 void QpackDecodedHeadersAccumulator::OnDecodingCompleted() {
-  DCHECK(!headers_decoded_);
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!headers_decoded_);
+  QUICHE_DCHECK(!error_detected_);
 
   headers_decoded_ = true;
 
@@ -64,8 +64,8 @@
 
 void QpackDecodedHeadersAccumulator::OnDecodingErrorDetected(
     absl::string_view error_message) {
-  DCHECK(!error_detected_);
-  DCHECK(!headers_decoded_);
+  QUICHE_DCHECK(!error_detected_);
+  QUICHE_DCHECK(!headers_decoded_);
 
   error_detected_ = true;
   // Might destroy |this|.
@@ -73,7 +73,7 @@
 }
 
 void QpackDecodedHeadersAccumulator::Decode(absl::string_view data) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   compressed_header_bytes_ += data.size();
   // Might destroy |this|.
@@ -81,8 +81,8 @@
 }
 
 void QpackDecodedHeadersAccumulator::EndHeaderBlock() {
-  DCHECK(!error_detected_);
-  DCHECK(!headers_decoded_);
+  QUICHE_DCHECK(!error_detected_);
+  QUICHE_DCHECK(!headers_decoded_);
 
   // Might destroy |this|.
   decoder_->EndHeaderBlock();
diff --git a/quic/core/qpack/qpack_decoder.cc b/quic/core/qpack/qpack_decoder.cc
index 35c64a0..c1ac28c 100644
--- a/quic/core/qpack/qpack_decoder.cc
+++ b/quic/core/qpack/qpack_decoder.cc
@@ -22,7 +22,7 @@
       encoder_stream_receiver_(this),
       maximum_blocked_streams_(maximum_blocked_streams),
       known_received_count_(0) {
-  DCHECK(encoder_stream_error_delegate_);
+  QUICHE_DCHECK(encoder_stream_error_delegate_);
 
   header_table_.SetMaximumDynamicTableCapacity(maximum_dynamic_table_capacity);
 }
@@ -38,13 +38,13 @@
 
 bool QpackDecoder::OnStreamBlocked(QuicStreamId stream_id) {
   auto result = blocked_streams_.insert(stream_id);
-  DCHECK(result.second);
+  QUICHE_DCHECK(result.second);
   return blocked_streams_.size() <= maximum_blocked_streams_;
 }
 
 void QpackDecoder::OnStreamUnblocked(QuicStreamId stream_id) {
   size_t result = blocked_streams_.erase(stream_id);
-  DCHECK_EQ(1u, result);
+  QUICHE_DCHECK_EQ(1u, result);
 }
 
 void QpackDecoder::OnDecodingCompleted(QuicStreamId stream_id,
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver.cc b/quic/core/qpack/qpack_decoder_stream_receiver.cc
index b43d6a0..aed660e 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver.cc
+++ b/quic/core/qpack/qpack_decoder_stream_receiver.cc
@@ -15,7 +15,7 @@
     : instruction_decoder_(QpackDecoderStreamLanguage(), this),
       delegate_(delegate),
       error_detected_(false) {
-  DCHECK(delegate_);
+  QUICHE_DCHECK(delegate_);
 }
 
 void QpackDecoderStreamReceiver::Decode(absl::string_view data) {
@@ -38,7 +38,7 @@
     return true;
   }
 
-  DCHECK_EQ(instruction, StreamCancellationInstruction());
+  QUICHE_DCHECK_EQ(instruction, StreamCancellationInstruction());
   delegate_->OnStreamCancellation(instruction_decoder_.varint());
   return true;
 }
@@ -46,7 +46,7 @@
 void QpackDecoderStreamReceiver::OnInstructionDecodingError(
     QpackInstructionDecoder::ErrorCode error_code,
     absl::string_view error_message) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   error_detected_ = true;
 
diff --git a/quic/core/qpack/qpack_encoder.cc b/quic/core/qpack/qpack_encoder.cc
index 6ad432b..8138266 100644
--- a/quic/core/qpack/qpack_encoder.cc
+++ b/quic/core/qpack/qpack_encoder.cc
@@ -38,7 +38,7 @@
       decoder_stream_receiver_(this),
       maximum_blocked_streams_(0),
       header_list_count_(0) {
-  DCHECK(decoder_stream_error_delegate_);
+  QUICHE_DCHECK(decoder_stream_error_delegate_);
 }
 
 QpackEncoder::~QpackEncoder() {}
@@ -275,8 +275,8 @@
 
   const QuicByteCount encoder_stream_buffered_byte_count =
       encoder_stream_sender_.BufferedByteCount();
-  DCHECK_GE(encoder_stream_buffered_byte_count,
-            initial_encoder_stream_buffered_byte_count);
+  QUICHE_DCHECK_GE(encoder_stream_buffered_byte_count,
+                   initial_encoder_stream_buffered_byte_count);
   if (encoder_stream_sent_byte_count) {
     *encoder_stream_sent_byte_count =
         encoder_stream_buffered_byte_count -
@@ -392,7 +392,7 @@
   // instructions are written.
 
   bool success = header_table_.SetDynamicTableCapacity(dynamic_table_capacity);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
 }
 
 bool QpackEncoder::SetMaximumBlockedStreams(uint64_t maximum_blocked_streams) {
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver.cc b/quic/core/qpack/qpack_encoder_stream_receiver.cc
index 3e6c21c..bf71faf 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver.cc
@@ -8,6 +8,7 @@
 #include "http2/decoder/decode_buffer.h"
 #include "http2/decoder/decode_status.h"
 #include "quic/core/qpack/qpack_instructions.h"
+#include "quic/platform/api/quic_logging.h"
 
 namespace quic {
 
@@ -15,7 +16,7 @@
     : instruction_decoder_(QpackEncoderStreamLanguage(), this),
       delegate_(delegate),
       error_detected_(false) {
-  DCHECK(delegate_);
+  QUICHE_DCHECK(delegate_);
 }
 
 void QpackEncoderStreamReceiver::Decode(absl::string_view data) {
@@ -46,7 +47,7 @@
     return true;
   }
 
-  DCHECK_EQ(instruction, SetDynamicTableCapacityInstruction());
+  QUICHE_DCHECK_EQ(instruction, SetDynamicTableCapacityInstruction());
   delegate_->OnSetDynamicTableCapacity(instruction_decoder_.varint());
   return true;
 }
@@ -54,7 +55,7 @@
 void QpackEncoderStreamReceiver::OnInstructionDecodingError(
     QpackInstructionDecoder::ErrorCode error_code,
     absl::string_view error_message) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   error_detected_ = true;
 
diff --git a/quic/core/qpack/qpack_header_table.cc b/quic/core/qpack/qpack_header_table.cc
index 24edc98..6171d84 100644
--- a/quic/core/qpack/qpack_header_table.cc
+++ b/quic/core/qpack/qpack_header_table.cc
@@ -60,7 +60,7 @@
   // Look for exact match in static table.
   auto index_it = static_index_.find(&query);
   if (index_it != static_index_.end()) {
-    DCHECK((*index_it)->IsStatic());
+    QUICHE_DCHECK((*index_it)->IsStatic());
     *index = (*index_it)->InsertionIndex();
     *is_static = true;
     return MatchType::kNameAndValue;
@@ -69,7 +69,7 @@
   // Look for exact match in dynamic table.
   index_it = dynamic_index_.find(&query);
   if (index_it != dynamic_index_.end()) {
-    DCHECK(!(*index_it)->IsStatic());
+    QUICHE_DCHECK(!(*index_it)->IsStatic());
     *index = (*index_it)->InsertionIndex();
     *is_static = false;
     return MatchType::kNameAndValue;
@@ -78,7 +78,7 @@
   // Look for name match in static table.
   auto name_index_it = static_name_index_.find(name);
   if (name_index_it != static_name_index_.end()) {
-    DCHECK(name_index_it->second->IsStatic());
+    QUICHE_DCHECK(name_index_it->second->IsStatic());
     *index = name_index_it->second->InsertionIndex();
     *is_static = true;
     return MatchType::kName;
@@ -87,7 +87,7 @@
   // Look for name match in dynamic table.
   name_index_it = dynamic_name_index_.find(name);
   if (name_index_it != dynamic_name_index_.end()) {
-    DCHECK(!name_index_it->second->IsStatic());
+    QUICHE_DCHECK(!name_index_it->second->IsStatic());
     *index = name_index_it->second->InsertionIndex();
     *is_static = false;
     return MatchType::kName;
@@ -117,11 +117,11 @@
     // An entry with the same name and value already exists.  It needs to be
     // replaced, because |dynamic_index_| tracks the most recent entry for a
     // given name and value.
-    DCHECK_GT(new_entry->InsertionIndex(),
-              (*index_result.first)->InsertionIndex());
+    QUICHE_DCHECK_GT(new_entry->InsertionIndex(),
+                     (*index_result.first)->InsertionIndex());
     dynamic_index_.erase(index_result.first);
     auto result = dynamic_index_.insert(new_entry);
-    CHECK(result.second);
+    QUICHE_CHECK(result.second);
   }
 
   auto name_result = dynamic_name_index_.insert({new_entry->name(), new_entry});
@@ -129,11 +129,11 @@
     // An entry with the same name already exists.  It needs to be replaced,
     // because |dynamic_name_index_| tracks the most recent entry for a given
     // name.
-    DCHECK_GT(new_entry->InsertionIndex(),
-              name_result.first->second->InsertionIndex());
+    QUICHE_DCHECK_GT(new_entry->InsertionIndex(),
+                     name_result.first->second->InsertionIndex());
     dynamic_name_index_.erase(name_result.first);
     auto result = dynamic_name_index_.insert({new_entry->name(), new_entry});
-    CHECK(result.second);
+    QUICHE_CHECK(result.second);
   }
 
   // Notify and deregister observers whose threshold is met, if any.
@@ -152,7 +152,7 @@
 
 uint64_t QpackHeaderTable::MaxInsertSizeWithoutEvictingGivenEntry(
     uint64_t index) const {
-  DCHECK_LE(dropped_entry_count_, index);
+  QUICHE_DCHECK_LE(dropped_entry_count_, index);
 
   if (index > inserted_entry_count()) {
     // All entries are allowed to be evicted.
@@ -180,7 +180,7 @@
   dynamic_table_capacity_ = capacity;
   EvictDownToCurrentCapacity();
 
-  DCHECK_LE(dynamic_table_size_, dynamic_table_capacity_);
+  QUICHE_DCHECK_LE(dynamic_table_size_, dynamic_table_capacity_);
 
   return true;
 }
@@ -198,7 +198,7 @@
 
 void QpackHeaderTable::RegisterObserver(uint64_t required_insert_count,
                                         Observer* observer) {
-  DCHECK_GT(required_insert_count, 0u);
+  QUICHE_DCHECK_GT(required_insert_count, 0u);
   observers_.insert({required_insert_count, observer});
 }
 
@@ -218,8 +218,8 @@
 }
 
 uint64_t QpackHeaderTable::draining_index(float draining_fraction) const {
-  DCHECK_LE(0.0, draining_fraction);
-  DCHECK_LE(draining_fraction, 1.0);
+  QUICHE_DCHECK_LE(0.0, draining_fraction);
+  QUICHE_DCHECK_LE(draining_fraction, 1.0);
 
   const uint64_t required_space = draining_fraction * dynamic_table_capacity_;
   uint64_t space_above_draining_index =
@@ -244,12 +244,12 @@
 
 void QpackHeaderTable::EvictDownToCurrentCapacity() {
   while (dynamic_table_size_ > dynamic_table_capacity_) {
-    DCHECK(!dynamic_entries_.empty());
+    QUICHE_DCHECK(!dynamic_entries_.empty());
 
     QpackEntry* const entry = &dynamic_entries_.front();
     const uint64_t entry_size = entry->Size();
 
-    DCHECK_GE(dynamic_table_size_, entry_size);
+    QUICHE_DCHECK_GE(dynamic_table_size_, entry_size);
     dynamic_table_size_ -= entry_size;
 
     auto index_it = dynamic_index_.find(entry);
diff --git a/quic/core/qpack/qpack_index_conversions.cc b/quic/core/qpack/qpack_index_conversions.cc
index c38668f..66f2ea3 100644
--- a/quic/core/qpack/qpack_index_conversions.cc
+++ b/quic/core/qpack/qpack_index_conversions.cc
@@ -13,14 +13,14 @@
 uint64_t QpackAbsoluteIndexToEncoderStreamRelativeIndex(
     uint64_t absolute_index,
     uint64_t inserted_entry_count) {
-  DCHECK_LT(absolute_index, inserted_entry_count);
+  QUICHE_DCHECK_LT(absolute_index, inserted_entry_count);
 
   return inserted_entry_count - absolute_index - 1;
 }
 
 uint64_t QpackAbsoluteIndexToRequestStreamRelativeIndex(uint64_t absolute_index,
                                                         uint64_t base) {
-  DCHECK_LT(absolute_index, base);
+  QUICHE_DCHECK_LT(absolute_index, base);
 
   return base - absolute_index - 1;
 }
diff --git a/quic/core/qpack/qpack_instruction_decoder.cc b/quic/core/qpack/qpack_instruction_decoder.cc
index b836ff7..bf786a4 100644
--- a/quic/core/qpack/qpack_instruction_decoder.cc
+++ b/quic/core/qpack/qpack_instruction_decoder.cc
@@ -34,8 +34,8 @@
       state_(State::kStartInstruction) {}
 
 bool QpackInstructionDecoder::Decode(absl::string_view data) {
-  DCHECK(!data.empty());
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!data.empty());
+  QUICHE_DCHECK(!error_detected_);
 
   while (true) {
     bool success = true;
@@ -73,9 +73,9 @@
     }
 
     // |success| must be false if an error is detected.
-    DCHECK(!error_detected_);
+    QUICHE_DCHECK(!error_detected_);
 
-    DCHECK_LE(bytes_consumed, data.size());
+    QUICHE_DCHECK_LE(bytes_consumed, data.size());
 
     data = absl::string_view(data.data() + bytes_consumed,
                              data.size() - bytes_consumed);
@@ -95,7 +95,7 @@
 }
 
 bool QpackInstructionDecoder::DoStartInstruction(absl::string_view data) {
-  DCHECK(!data.empty());
+  QUICHE_DCHECK(!data.empty());
 
   instruction_ = LookupOpcode(data[0]);
   field_ = instruction_->fields.begin();
@@ -133,7 +133,7 @@
 }
 
 bool QpackInstructionDecoder::DoReadBit(absl::string_view data) {
-  DCHECK(!data.empty());
+  QUICHE_DCHECK(!data.empty());
 
   switch (field_->type) {
     case QpackInstructionFieldType::kSbit: {
@@ -148,7 +148,7 @@
     case QpackInstructionFieldType::kName:
     case QpackInstructionFieldType::kValue: {
       const uint8_t prefix_length = field_->param;
-      DCHECK_GE(7, prefix_length);
+      QUICHE_DCHECK_GE(7, prefix_length);
       const uint8_t bitmask = 1 << prefix_length;
       is_huffman_encoded_ = (data[0] & bitmask) == bitmask;
 
@@ -164,11 +164,11 @@
 
 bool QpackInstructionDecoder::DoVarintStart(absl::string_view data,
                                             size_t* bytes_consumed) {
-  DCHECK(!data.empty());
-  DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
-         field_->type == QpackInstructionFieldType::kVarint2 ||
-         field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(!data.empty());
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
+                field_->type == QpackInstructionFieldType::kVarint2 ||
+                field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   http2::DecodeBuffer buffer(data.data() + 1, data.size() - 1);
   http2::DecodeStatus status =
@@ -193,11 +193,11 @@
 
 bool QpackInstructionDecoder::DoVarintResume(absl::string_view data,
                                              size_t* bytes_consumed) {
-  DCHECK(!data.empty());
-  DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
-         field_->type == QpackInstructionFieldType::kVarint2 ||
-         field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(!data.empty());
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
+                field_->type == QpackInstructionFieldType::kVarint2 ||
+                field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   http2::DecodeBuffer buffer(data);
   http2::DecodeStatus status = varint_decoder_.Resume(&buffer);
@@ -208,8 +208,8 @@
       state_ = State::kVarintDone;
       return true;
     case http2::DecodeStatus::kDecodeInProgress:
-      DCHECK_EQ(*bytes_consumed, data.size());
-      DCHECK(buffer.Empty());
+      QUICHE_DCHECK_EQ(*bytes_consumed, data.size());
+      QUICHE_DCHECK(buffer.Empty());
       return true;
     case http2::DecodeStatus::kDecodeError:
       OnError(ErrorCode::INTEGER_TOO_LARGE, "Encoded integer too large.");
@@ -221,10 +221,10 @@
 }
 
 bool QpackInstructionDecoder::DoVarintDone() {
-  DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
-         field_->type == QpackInstructionFieldType::kVarint2 ||
-         field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
+                field_->type == QpackInstructionFieldType::kVarint2 ||
+                field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   if (field_->type == QpackInstructionFieldType::kVarint) {
     varint_ = varint_decoder_.value();
@@ -266,18 +266,18 @@
 
 bool QpackInstructionDecoder::DoReadString(absl::string_view data,
                                            size_t* bytes_consumed) {
-  DCHECK(!data.empty());
-  DCHECK(field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(!data.empty());
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   std::string* const string =
       (field_->type == QpackInstructionFieldType::kName) ? &name_ : &value_;
-  DCHECK_LT(string->size(), string_length_);
+  QUICHE_DCHECK_LT(string->size(), string_length_);
 
   *bytes_consumed = std::min(string_length_ - string->size(), data.size());
   string->append(data.data(), *bytes_consumed);
 
-  DCHECK_LE(string->size(), string_length_);
+  QUICHE_DCHECK_LE(string->size(), string_length_);
   if (string->size() == string_length_) {
     state_ = State::kReadStringDone;
   }
@@ -285,12 +285,12 @@
 }
 
 bool QpackInstructionDecoder::DoReadStringDone() {
-  DCHECK(field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   std::string* const string =
       (field_->type == QpackInstructionFieldType::kName) ? &name_ : &value_;
-  DCHECK_EQ(string->size(), string_length_);
+  QUICHE_DCHECK_EQ(string->size(), string_length_);
 
   if (is_huffman_encoded_) {
     huffman_decoder_.Reset();
@@ -319,13 +319,13 @@
   }
   // |language_| should be defined such that instruction opcodes cover every
   // possible input.
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
 void QpackInstructionDecoder::OnError(ErrorCode error_code,
                                       absl::string_view error_message) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   error_detected_ = true;
   delegate_->OnInstructionDecodingError(error_code, error_message);
diff --git a/quic/core/qpack/qpack_instruction_encoder.cc b/quic/core/qpack/qpack_instruction_encoder.cc
index 72d92dd..527c43c 100644
--- a/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quic/core/qpack/qpack_instruction_encoder.cc
@@ -25,14 +25,14 @@
 void QpackInstructionEncoder::Encode(
     const QpackInstructionWithValues& instruction_with_values,
     std::string* output) {
-  DCHECK(instruction_with_values.instruction());
+  QUICHE_DCHECK(instruction_with_values.instruction());
 
   state_ = State::kOpcode;
   instruction_ = instruction_with_values.instruction();
   field_ = instruction_->fields.begin();
 
   // Field list must not be empty.
-  DCHECK(field_ != instruction_->fields.end());
+  QUICHE_DCHECK(field_ != instruction_->fields.end());
 
   do {
     switch (state_) {
@@ -60,11 +60,11 @@
     }
   } while (field_ != instruction_->fields.end());
 
-  DCHECK(state_ == State::kStartField);
+  QUICHE_DCHECK(state_ == State::kStartField);
 }
 
 void QpackInstructionEncoder::DoOpcode() {
-  DCHECK_EQ(0u, byte_);
+  QUICHE_DCHECK_EQ(0u, byte_);
 
   byte_ = instruction_->opcode.value;
 
@@ -88,10 +88,10 @@
 }
 
 void QpackInstructionEncoder::DoSBit(bool s_bit) {
-  DCHECK(field_->type == QpackInstructionFieldType::kSbit);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kSbit);
 
   if (s_bit) {
-    DCHECK_EQ(0, byte_ & field_->param);
+    QUICHE_DCHECK_EQ(0, byte_ & field_->param);
 
     byte_ |= field_->param;
   }
@@ -103,10 +103,10 @@
 void QpackInstructionEncoder::DoVarintEncode(uint64_t varint,
                                              uint64_t varint2,
                                              std::string* output) {
-  DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
-         field_->type == QpackInstructionFieldType::kVarint2 ||
-         field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
+                field_->type == QpackInstructionFieldType::kVarint2 ||
+                field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
   uint64_t integer_to_encode;
   switch (field_->type) {
     case QpackInstructionFieldType::kVarint:
@@ -136,8 +136,8 @@
 
 void QpackInstructionEncoder::DoStartString(absl::string_view name,
                                             absl::string_view value) {
-  DCHECK(field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   absl::string_view string_to_write =
       (field_->type == QpackInstructionFieldType::kName) ? name : value;
@@ -147,7 +147,7 @@
   use_huffman_ = encoded_size < string_length_;
 
   if (use_huffman_) {
-    DCHECK_EQ(0, byte_ & (1 << field_->param));
+    QUICHE_DCHECK_EQ(0, byte_ & (1 << field_->param));
     byte_ |= (1 << field_->param);
 
     string_length_ = encoded_size;
@@ -159,8 +159,8 @@
 void QpackInstructionEncoder::DoWriteString(absl::string_view name,
                                             absl::string_view value,
                                             std::string* output) {
-  DCHECK(field_->type == QpackInstructionFieldType::kName ||
-         field_->type == QpackInstructionFieldType::kValue);
+  QUICHE_DCHECK(field_->type == QpackInstructionFieldType::kName ||
+                field_->type == QpackInstructionFieldType::kValue);
 
   absl::string_view string_to_write =
       (field_->type == QpackInstructionFieldType::kName) ? name : value;
diff --git a/quic/core/qpack/qpack_instructions.cc b/quic/core/qpack/qpack_instructions.cc
index e3f37a7..7f95762 100644
--- a/quic/core/qpack/qpack_instructions.cc
+++ b/quic/core/qpack/qpack_instructions.cc
@@ -19,7 +19,7 @@
 void ValidateLangague(const QpackLanguage* language) {
 #ifndef NDEBUG
   for (const auto* instruction : *language) {
-    DCHECK_EQ(0, instruction->opcode.value & ~instruction->opcode.mask);
+    QUICHE_DCHECK_EQ(0, instruction->opcode.value & ~instruction->opcode.mask);
   }
 
   for (uint8_t byte = 0; byte < std::numeric_limits<uint8_t>::max(); ++byte) {
@@ -29,7 +29,7 @@
         ++match_count;
       }
     }
-    DCHECK_EQ(1u, match_count) << static_cast<int>(byte);
+    QUICHE_DCHECK_EQ(1u, match_count) << static_cast<int>(byte);
   }
 #else
   (void)language;
diff --git a/quic/core/qpack/qpack_progressive_decoder.cc b/quic/core/qpack/qpack_progressive_decoder.cc
index 87af1b7..ac07fed 100644
--- a/quic/core/qpack/qpack_progressive_decoder.cc
+++ b/quic/core/qpack/qpack_progressive_decoder.cc
@@ -47,7 +47,7 @@
 }
 
 void QpackProgressiveDecoder::Decode(absl::string_view data) {
-  DCHECK(decoding_);
+  QUICHE_DCHECK(decoding_);
 
   if (data.empty() || error_detected_) {
     return;
@@ -56,14 +56,14 @@
   // Decode prefix byte by byte until the first (and only) instruction is
   // decoded.
   while (!prefix_decoded_) {
-    DCHECK(!blocked_);
+    QUICHE_DCHECK(!blocked_);
 
     if (!prefix_decoder_->Decode(data.substr(0, 1))) {
       return;
     }
 
     // |prefix_decoder_->Decode()| must return false if an error is detected.
-    DCHECK(!error_detected_);
+    QUICHE_DCHECK(!error_detected_);
 
     data = data.substr(1);
     if (data.empty()) {
@@ -74,14 +74,14 @@
   if (blocked_) {
     buffer_.append(data.data(), data.size());
   } else {
-    DCHECK(buffer_.empty());
+    QUICHE_DCHECK(buffer_.empty());
 
     instruction_decoder_.Decode(data);
   }
 }
 
 void QpackProgressiveDecoder::EndHeaderBlock() {
-  DCHECK(decoding_);
+  QUICHE_DCHECK(decoding_);
   decoding_ = false;
 
   if (!blocked_) {
@@ -90,7 +90,7 @@
 }
 
 void QpackProgressiveDecoder::OnError(absl::string_view error_message) {
-  DCHECK(!error_detected_);
+  QUICHE_DCHECK(!error_detected_);
 
   error_detected_ = true;
   // Might destroy |this|.
@@ -103,8 +103,9 @@
     return DoPrefixInstruction();
   }
 
-  DCHECK(prefix_decoded_);
-  DCHECK_LE(required_insert_count_, header_table_->inserted_entry_count());
+  QUICHE_DCHECK(prefix_decoded_);
+  QUICHE_DCHECK_LE(required_insert_count_,
+                   header_table_->inserted_entry_count());
 
   if (instruction == QpackIndexedHeaderFieldInstruction()) {
     return DoIndexedHeaderFieldInstruction();
@@ -118,7 +119,7 @@
   if (instruction == QpackLiteralHeaderFieldPostBaseInstruction()) {
     return DoLiteralHeaderFieldPostBaseInstruction();
   }
-  DCHECK_EQ(instruction, QpackLiteralHeaderFieldInstruction());
+  QUICHE_DCHECK_EQ(instruction, QpackLiteralHeaderFieldInstruction());
   return DoLiteralHeaderFieldInstruction();
 }
 
@@ -132,7 +133,7 @@
 }
 
 void QpackProgressiveDecoder::OnInsertCountReachedThreshold() {
-  DCHECK(blocked_);
+  QUICHE_DCHECK(blocked_);
 
   // Clear |blocked_| before calling instruction_decoder_.Decode() below,
   // because that might destroy |this| and ~QpackProgressiveDecoder() needs to
@@ -172,7 +173,7 @@
       return false;
     }
 
-    DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
+    QUICHE_DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
     required_insert_count_so_far_ =
         std::max(required_insert_count_so_far_, absolute_index + 1);
 
@@ -212,7 +213,7 @@
     return false;
   }
 
-  DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
+  QUICHE_DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
   required_insert_count_so_far_ =
       std::max(required_insert_count_so_far_, absolute_index + 1);
 
@@ -242,7 +243,7 @@
       return false;
     }
 
-    DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
+    QUICHE_DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
     required_insert_count_so_far_ =
         std::max(required_insert_count_so_far_, absolute_index + 1);
 
@@ -282,7 +283,7 @@
     return false;
   }
 
-  DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
+  QUICHE_DCHECK_LT(absolute_index, std::numeric_limits<uint64_t>::max());
   required_insert_count_so_far_ =
       std::max(required_insert_count_so_far_, absolute_index + 1);
 
@@ -306,7 +307,7 @@
 }
 
 bool QpackProgressiveDecoder::DoPrefixInstruction() {
-  DCHECK(!prefix_decoded_);
+  QUICHE_DCHECK(!prefix_decoded_);
 
   if (!QpackDecodeRequiredInsertCount(
           prefix_decoder_->varint(), header_table_->max_entries(),
@@ -337,9 +338,9 @@
 }
 
 void QpackProgressiveDecoder::FinishDecoding() {
-  DCHECK(buffer_.empty());
-  DCHECK(!blocked_);
-  DCHECK(!decoding_);
+  QUICHE_DCHECK(buffer_.empty());
+  QUICHE_DCHECK(!blocked_);
+  QUICHE_DCHECK(!decoding_);
 
   if (error_detected_) {
     return;
diff --git a/quic/core/qpack/qpack_receive_stream.cc b/quic/core/qpack/qpack_receive_stream.cc
index 00fb394..65e290f 100644
--- a/quic/core/qpack/qpack_receive_stream.cc
+++ b/quic/core/qpack/qpack_receive_stream.cc
@@ -23,7 +23,7 @@
 void QpackReceiveStream::OnDataAvailable() {
   iovec iov;
   while (!reading_stopped() && sequencer()->GetReadableRegion(&iov)) {
-    DCHECK(!sequencer()->IsClosed());
+    QUICHE_DCHECK(!sequencer()->IsClosed());
 
     receiver_->Decode(absl::string_view(
         reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
diff --git a/quic/core/qpack/qpack_required_insert_count.cc b/quic/core/qpack/qpack_required_insert_count.cc
index 841af28..6e17b24 100644
--- a/quic/core/qpack/qpack_required_insert_count.cc
+++ b/quic/core/qpack/qpack_required_insert_count.cc
@@ -30,17 +30,18 @@
 
   // |max_entries| is calculated by dividing an unsigned 64-bit integer by 32,
   // precluding all calculations in this method from overflowing.
-  DCHECK_LE(max_entries, std::numeric_limits<uint64_t>::max() / 32);
+  QUICHE_DCHECK_LE(max_entries, std::numeric_limits<uint64_t>::max() / 32);
 
   if (encoded_required_insert_count > 2 * max_entries) {
     return false;
   }
 
   *required_insert_count = encoded_required_insert_count - 1;
-  DCHECK_LT(*required_insert_count, std::numeric_limits<uint64_t>::max() / 16);
+  QUICHE_DCHECK_LT(*required_insert_count,
+                   std::numeric_limits<uint64_t>::max() / 16);
 
   uint64_t current_wrapped = total_number_of_inserts % (2 * max_entries);
-  DCHECK_LT(current_wrapped, std::numeric_limits<uint64_t>::max() / 16);
+  QUICHE_DCHECK_LT(current_wrapped, std::numeric_limits<uint64_t>::max() / 16);
 
   if (current_wrapped >= *required_insert_count + max_entries) {
     // Required Insert Count wrapped around 1 extra time.
diff --git a/quic/core/qpack/qpack_static_table.cc b/quic/core/qpack/qpack_static_table.cc
index 8a65b07..869d09c 100644
--- a/quic/core/qpack/qpack_static_table.cc
+++ b/quic/core/qpack/qpack_static_table.cc
@@ -130,7 +130,7 @@
     auto* table = new QpackStaticTable();
     table->Initialize(QpackStaticTableVector().data(),
                       QpackStaticTableVector().size());
-    CHECK(table->IsInitialized());
+    QUICHE_CHECK(table->IsInitialized());
     return table;
   }();
   return *shared_static_table;
diff --git a/quic/core/qpack/value_splitting_header_list.cc b/quic/core/qpack/value_splitting_header_list.cc
index 80d7dac..9d4231d 100644
--- a/quic/core/qpack/value_splitting_header_list.cc
+++ b/quic/core/qpack/value_splitting_header_list.cc
@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include "quic/core/qpack/value_splitting_header_list.h"
+
 #include "absl/strings/string_view.h"
+#include "quic/platform/api/quic_logging.h"
 
 namespace quic {
 namespace {
@@ -61,7 +63,7 @@
 }
 
 void ValueSplittingHeaderList::const_iterator::UpdateHeaderField() {
-  DCHECK(value_start_ != absl::string_view::npos);
+  QUICHE_DCHECK(value_start_ != absl::string_view::npos);
 
   if (header_list_iterator_ == header_list_->end()) {
     return;
@@ -91,7 +93,7 @@
 ValueSplittingHeaderList::ValueSplittingHeaderList(
     const spdy::Http2HeaderBlock* header_list)
     : header_list_(header_list) {
-  DCHECK(header_list_);
+  QUICHE_DCHECK(header_list_);
 }
 
 ValueSplittingHeaderList::const_iterator ValueSplittingHeaderList::begin()
diff --git a/quic/core/quic_alarm.cc b/quic/core/quic_alarm.cc
index cdbe9bf..bfef316 100644
--- a/quic/core/quic_alarm.cc
+++ b/quic/core/quic_alarm.cc
@@ -12,8 +12,8 @@
 QuicAlarm::~QuicAlarm() {}
 
 void QuicAlarm::Set(QuicTime new_deadline) {
-  DCHECK(!IsSet());
-  DCHECK(new_deadline.IsInitialized());
+  QUICHE_DCHECK(!IsSet());
+  QUICHE_DCHECK(new_deadline.IsInitialized());
   deadline_ = new_deadline;
   SetImpl();
 }
diff --git a/quic/core/quic_alarm_test.cc b/quic/core/quic_alarm_test.cc
index 29ff974..8f7296c 100644
--- a/quic/core/quic_alarm_test.cc
+++ b/quic/core/quic_alarm_test.cc
@@ -24,7 +24,7 @@
   void set_alarm(QuicAlarm* alarm) { alarm_ = alarm; }
 
   void OnAlarm() override {
-    DCHECK(alarm_);
+    QUICHE_DCHECK(alarm_);
     delete alarm_;
   }
 
@@ -46,12 +46,12 @@
 
  protected:
   void SetImpl() override {
-    DCHECK(deadline().IsInitialized());
+    QUICHE_DCHECK(deadline().IsInitialized());
     scheduled_ = true;
   }
 
   void CancelImpl() override {
-    DCHECK(!deadline().IsInitialized());
+    QUICHE_DCHECK(!deadline().IsInitialized());
     scheduled_ = false;
   }
 
diff --git a/quic/core/quic_arena_scoped_ptr_test.cc b/quic/core/quic_arena_scoped_ptr_test.cc
index 45bc142..6388cf3 100644
--- a/quic/core/quic_arena_scoped_ptr_test.cc
+++ b/quic/core/quic_arena_scoped_ptr_test.cc
@@ -29,7 +29,7 @@
     case TestParam::kFromArena:
       return "arena";
   }
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return "?";
 }
 
@@ -40,11 +40,11 @@
     switch (GetParam()) {
       case TestParam::kFromHeap:
         ptr = QuicArenaScopedPtr<TestObject>(new TestObject(value));
-        CHECK(!ptr.is_from_arena());
+        QUICHE_CHECK(!ptr.is_from_arena());
         break;
       case TestParam::kFromArena:
         ptr = arena_.New<TestObject>(value);
-        CHECK(ptr.is_from_arena());
+        QUICHE_CHECK(ptr.is_from_arena());
         break;
     }
     return ptr;
diff --git a/quic/core/quic_buffered_packet_store.cc b/quic/core/quic_buffered_packet_store.cc
index 893fc82..b9e3d10 100644
--- a/quic/core/quic_buffered_packet_store.cc
+++ b/quic/core/quic_buffered_packet_store.cc
@@ -110,7 +110,7 @@
     undecryptable_packets_.back().second.ietf_quic = ietf_quic;
     undecryptable_packets_.back().second.version = version;
   }
-  CHECK(QuicContainsKey(undecryptable_packets_, connection_id));
+  QUICHE_CHECK(QuicContainsKey(undecryptable_packets_, connection_id));
   BufferedPacketList& queue =
       undecryptable_packets_.find(connection_id)->second;
 
@@ -243,7 +243,7 @@
   connections_with_chlo_.pop_front();
 
   BufferedPacketList packets = DeliverPackets(*connection_id);
-  DCHECK(!packets.buffered_packets.empty())
+  QUICHE_DCHECK(!packets.buffered_packets.empty())
       << "Try to deliver connectons without CHLO";
   return packets;
 }
@@ -258,8 +258,8 @@
     const ParsedQuicVersion& version,
     const QuicReceivedPacket& packet,
     std::vector<std::string>* out_alpns) {
-  DCHECK_NE(out_alpns, nullptr);
-  DCHECK_EQ(version.handshake_protocol, PROTOCOL_TLS1_3);
+  QUICHE_DCHECK_NE(out_alpns, nullptr);
+  QUICHE_DCHECK_EQ(version.handshake_protocol, PROTOCOL_TLS1_3);
   auto it = undecryptable_packets_.find(connection_id);
   if (it == undecryptable_packets_.end()) {
     QUIC_BUG << "Cannot ingest packet for unknown connection ID "
diff --git a/quic/core/quic_clock.cc b/quic/core/quic_clock.cc
index f057b40..4d865b5 100644
--- a/quic/core/quic_clock.cc
+++ b/quic/core/quic_clock.cc
@@ -38,7 +38,7 @@
 }
 
 void QuicClock::SetCalibrationOffset(QuicTime::Delta offset) {
-  DCHECK(!is_calibrated_) << "A clock should only be calibrated once";
+  QUICHE_DCHECK(!is_calibrated_) << "A clock should only be calibrated once";
   calibration_offset_ = offset;
   is_calibrated_ = true;
 }
diff --git a/quic/core/quic_coalesced_packet.cc b/quic/core/quic_coalesced_packet.cc
index 47aa93b..2ae9b41 100644
--- a/quic/core/quic_coalesced_packet.cc
+++ b/quic/core/quic_coalesced_packet.cc
@@ -30,10 +30,10 @@
   if (length_ == 0) {
 #ifndef NDEBUG
     for (const auto& buffer : encrypted_buffers_) {
-      DCHECK(buffer.empty());
+      QUICHE_DCHECK(buffer.empty());
     }
 #endif
-    DCHECK(initial_packet_ == nullptr);
+    QUICHE_DCHECK(initial_packet_ == nullptr);
     // This is the first packet, set max_packet_length and self/peer
     // addresses.
     max_packet_length_ = current_max_packet_length;
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 725b513..893d822 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -37,7 +37,7 @@
                          uint32_t default_value,
                          uint32_t* out,
                          std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   QuicErrorCode error = msg.GetUint32(tag, out);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
@@ -112,7 +112,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType /*hello_type*/,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   if (tag_ == 0) {
     *error_details =
         "This parameter does not support reading from CryptoHandshakeMessage";
@@ -201,7 +201,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType /*hello_type*/,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   uint32_t receive_value32;
   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value32);
   // GetUint32 is guaranteed to always initialize receive_value32.
@@ -269,7 +269,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType /*hello_type*/,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   QuicErrorCode error = peer_hello.GetUint128(tag_, &receive_value_);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
@@ -339,7 +339,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType /*hello_type*/,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
   QuicTagVector values;
   QuicErrorCode error = peer_hello.GetTaglist(tag_, &values);
   switch (error) {
@@ -942,7 +942,7 @@
 
 const std::pair<QuicConnectionId, QuicUint128>&
 QuicConfig::ReceivedPreferredAddressConnectionIdAndToken() const {
-  DCHECK(HasReceivedPreferredAddressConnectionIdAndToken());
+  QUICHE_DCHECK(HasReceivedPreferredAddressConnectionIdAndToken());
   return *preferred_address_connection_id_and_token_;
 }
 
@@ -1092,7 +1092,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     std::string* error_details) {
-  DCHECK(error_details != nullptr);
+  QUICHE_DCHECK(error_details != nullptr);
 
   QuicErrorCode error = QUIC_NO_ERROR;
   if (error == QUIC_NO_ERROR) {
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 5c14542..df09b23 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -69,8 +69,8 @@
   AckAlarmDelegate& operator=(const AckAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->ack_frame_updated());
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->ack_frame_updated());
+    QUICHE_DCHECK(connection_->connected());
     QuicConnection::ScopedPacketFlusher flusher(connection_);
     if (connection_->SupportsMultiplePacketNumberSpaces()) {
       connection_->SendAllPendingAcks();
@@ -95,7 +95,7 @@
       delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     connection_->OnRetransmissionTimeout();
   }
 
@@ -113,7 +113,7 @@
   SendAlarmDelegate& operator=(const SendAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     connection_->WriteAndBundleAcksIfNotBlocked();
   }
 
@@ -129,7 +129,7 @@
   PingAlarmDelegate& operator=(const PingAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     connection_->OnPingTimeout();
   }
 
@@ -146,7 +146,7 @@
       delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     connection_->DiscoverMtu();
   }
 
@@ -164,7 +164,7 @@
       const ProcessUndecryptablePacketsAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     QuicConnection::ScopedPacketFlusher flusher(connection_);
     connection_->MaybeProcessUndecryptablePackets();
   }
@@ -183,7 +183,7 @@
       const DiscardPreviousOneRttKeysAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     connection_->DiscardPreviousOneRttKeys();
   }
 
@@ -201,7 +201,7 @@
       const DiscardZeroRttDecryptionKeysAlarmDelegate&) = delete;
 
   void OnAlarm() override {
-    DCHECK(connection_->connected());
+    QUICHE_DCHECK(connection_->connected());
     QUIC_DLOG(INFO) << "0-RTT discard alarm fired";
     connection_->RemoveDecrypter(ENCRYPTION_ZERO_RTT);
   }
@@ -375,8 +375,8 @@
       most_recent_frame_type_(NUM_FRAME_TYPES) {
   QUIC_BUG_IF(!start_peer_migration_earlier_ && send_path_response_);
 
-  DCHECK(perspective_ == Perspective::IS_CLIENT ||
-         self_address_.IsInitialized());
+  QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT ||
+                self_address_.IsInitialized());
 
   if (use_encryption_level_context_) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_use_encryption_level_context);
@@ -406,8 +406,8 @@
                          : kDefaultMaxPacketSize);
   uber_received_packet_manager_.set_max_ack_ranges(255);
   MaybeEnableMultiplePacketNumberSpacesSupport();
-  DCHECK(perspective_ == Perspective::IS_CLIENT ||
-         supported_versions.size() == 1);
+  QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT ||
+                supported_versions.size() == 1);
   InstallInitialCrypters(server_connection_id_);
 
   // On the server side, version negotiation has been done by the dispatcher,
@@ -461,7 +461,7 @@
 }
 
 bool QuicConnection::ValidateConfigConnectionIds(const QuicConfig& config) {
-  DCHECK(config.negotiated());
+  QUICHE_DCHECK(config.negotiated());
   if (!version().UsesTls()) {
     // QUIC+TLS is required to transmit connection ID transport parameters.
     return true;
@@ -837,9 +837,9 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.  (Check for a bug regression.)
-  DCHECK_EQ(server_connection_id_, packet.connection_id);
-  DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-  DCHECK(!version().HasIetfInvariantHeader());
+  QUICHE_DCHECK_EQ(server_connection_id_, packet.connection_id);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+  QUICHE_DCHECK(!version().HasIetfInvariantHeader());
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
@@ -875,7 +875,7 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.  (Check for a bug regression.)
-  DCHECK_EQ(server_connection_id_, packet.connection_id);
+  QUICHE_DCHECK_EQ(server_connection_id_, packet.connection_id);
   if (perspective_ == Perspective::IS_SERVER) {
     const std::string error_details =
         "Server received version negotiation packet.";
@@ -924,7 +924,7 @@
                                    absl::string_view retry_token,
                                    absl::string_view retry_integrity_tag,
                                    absl::string_view retry_without_tag) {
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
   if (version().UsesTls()) {
     if (!CryptoUtils::ValidateRetryIntegrityTag(
             version(), server_connection_id_, retry_without_tag,
@@ -949,7 +949,7 @@
   if (!original_destination_connection_id_.has_value()) {
     original_destination_connection_id_ = server_connection_id_;
   }
-  DCHECK(!retry_source_connection_id_.has_value())
+  QUICHE_DCHECK(!retry_source_connection_id_.has_value())
       << retry_source_connection_id_.value();
   retry_source_connection_id_ = new_connection_id;
   server_connection_id_ = new_connection_id;
@@ -980,12 +980,12 @@
                   << original_destination_connection_id
                   << " on connection with server_connection_id "
                   << server_connection_id_;
-  DCHECK_NE(original_destination_connection_id, server_connection_id_);
+  QUICHE_DCHECK_NE(original_destination_connection_id, server_connection_id_);
   if (!HasIncomingConnectionId(original_destination_connection_id)) {
     incoming_connection_ids_.push_back(original_destination_connection_id);
   }
   InstallInitialCrypters(original_destination_connection_id);
-  DCHECK(!original_destination_connection_id_.has_value())
+  QUICHE_DCHECK(!original_destination_connection_id_.has_value())
       << original_destination_connection_id_.value();
   original_destination_connection_id_ = original_destination_connection_id;
 }
@@ -1027,7 +1027,7 @@
     // If this is a server, the dispatcher routes each packet to the
     // QuicConnection responsible for the packet's connection ID.  So if control
     // arrives here and this is a server, the dispatcher must be malfunctioning.
-    DCHECK_NE(Perspective::IS_SERVER, perspective_);
+    QUICHE_DCHECK_NE(Perspective::IS_SERVER, perspective_);
     return false;
   }
 
@@ -1066,11 +1066,11 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.
-  DCHECK(GetServerConnectionIdAsRecipient(header, perspective_) ==
-             server_connection_id_ ||
-         HasIncomingConnectionId(
-             GetServerConnectionIdAsRecipient(header, perspective_)) ||
-         PacketCanReplaceConnectionId(header, perspective_));
+  QUICHE_DCHECK(GetServerConnectionIdAsRecipient(header, perspective_) ==
+                    server_connection_id_ ||
+                HasIncomingConnectionId(
+                    GetServerConnectionIdAsRecipient(header, perspective_)) ||
+                PacketCanReplaceConnectionId(header, perspective_));
 
   if (packet_creator_.HasPendingFrames()) {
     // Incoming packets may change a queued ACK frame.
@@ -1094,7 +1094,7 @@
 }
 
 void QuicConnection::OnSuccessfulMigration() {
-  DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   if (IsPathDegrading()) {
     // If path was previously degrading, and migration is successful after
     // probing, restart the path degrading and blackhole detection.
@@ -1252,7 +1252,7 @@
       stats_.address_validated_via_token = true;
     }
   }
-  DCHECK(connected_);
+  QUICHE_DCHECK(connected_);
   return true;
 }
 
@@ -1606,7 +1606,7 @@
                               "is closed. Last frame: "
                            << most_recent_frame_type_;
   if (has_path_challenge_in_current_packet_) {
-    DCHECK(send_path_response_);
+    QUICHE_DCHECK(send_path_response_);
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_send_path_response, 2, 5);
     // Only respond to the 1st PATH_CHALLENGE.
     return true;
@@ -1960,7 +1960,7 @@
   }
 
   if (IsCurrentPacketConnectivityProbing()) {
-    DCHECK(!version().HasIetfQuicFrames());
+    QUICHE_DCHECK(!version().HasIetfQuicFrames());
     ++stats_.num_connectivity_probing_received;
   }
 
@@ -2065,8 +2065,8 @@
     const QuicIetfStatelessResetPacket& /*packet*/) {
   // TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
   // debug_visitor_.
-  DCHECK(version().HasIetfInvariantHeader());
-  DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+  QUICHE_DCHECK(version().HasIetfInvariantHeader());
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
 
   if (use_path_validator_) {
     if (!IsDefaultPath(last_packet_destination_address_,
@@ -2097,7 +2097,7 @@
 }
 
 void QuicConnection::OnKeyUpdate(KeyUpdateReason reason) {
-  DCHECK(support_key_update_for_connection_);
+  QUICHE_DCHECK(support_key_update_for_connection_);
   QUIC_DLOG(INFO) << ENDPOINT << "Key phase updated for " << reason;
 
   lowest_packet_sent_in_current_key_phase_.Clear();
@@ -2171,7 +2171,7 @@
 }
 
 const QuicFrame QuicConnection::GetUpdatedAckFrame() {
-  DCHECK(!uber_received_packet_manager_.IsAckFrameEmpty(
+  QUICHE_DCHECK(!uber_received_packet_manager_.IsAckFrameEmpty(
       QuicUtils::GetPacketNumberSpace(encryption_level_)))
       << "Try to retrieve an empty ACK frame";
   return uber_received_packet_manager_.GetUpdatedAckFrame(
@@ -2222,7 +2222,7 @@
   if (!legacy_version_encapsulation_enabled_) {
     return;
   }
-  DCHECK(!legacy_version_encapsulation_in_progress_);
+  QUICHE_DCHECK(!legacy_version_encapsulation_in_progress_);
   QUIC_BUG_IF(!packet_creator_.CanSetMaxPacketLength())
       << "Cannot activate Legacy Version Encapsulation mid-packet";
   QUIC_BUG_IF(coalesced_packet_.length() != 0u)
@@ -2236,7 +2236,7 @@
   }
   // Flush any remaining packet before disactivating encapsulation.
   packet_creator_.FlushCurrentPacket();
-  DCHECK(legacy_version_encapsulation_enabled_);
+  QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
   legacy_version_encapsulation_in_progress_ = false;
   MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
 }
@@ -2373,7 +2373,7 @@
                 << decryption_level
                 << " while connection is at encryption level "
                 << encryption_level_;
-  DCHECK(EncryptionLevelIsValid(decryption_level));
+  QUICHE_DCHECK(EncryptionLevelIsValid(decryption_level));
   if (encryption_level_ != ENCRYPTION_FORWARD_SECURE) {
     ++stats_.undecryptable_packets_received_before_handshake_complete;
   }
@@ -2393,7 +2393,7 @@
     stats_.num_failed_authentication_packets_received++;
     if (version().UsesTls()) {
       // Should always be non-null if has_decryption_key is true.
-      DCHECK(framer_.GetDecrypter(decryption_level));
+      QUICHE_DCHECK(framer_.GetDecrypter(decryption_level));
       const QuicPacketCount integrity_limit =
           framer_.GetDecrypter(decryption_level)->GetIntegrityLimit();
       QUIC_DVLOG(2) << ENDPOINT << "Checking AEAD integrity limits:"
@@ -2464,7 +2464,7 @@
 void QuicConnection::MaybeUpdatePacketCreatorMaxPacketLengthAndPadding() {
   QuicByteCount max_packet_length = GetLimitedMaxPacketSize(long_term_mtu_);
   if (legacy_version_encapsulation_in_progress_) {
-    DCHECK(legacy_version_encapsulation_enabled_);
+    QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
     const QuicByteCount minimum_overhead =
         QuicLegacyVersionEncapsulator::GetMinimumOverhead(
             legacy_version_encapsulation_sni_);
@@ -2713,7 +2713,7 @@
 
   if (!version_negotiated_) {
     if (perspective_ == Perspective::IS_CLIENT) {
-      DCHECK(!header.version_flag || header.form != GOOGLE_QUIC_PACKET);
+      QUICHE_DCHECK(!header.version_flag || header.form != GOOGLE_QUIC_PACKET);
       if (!version().HasIetfInvariantHeader()) {
         // If the client gets a packet without the version flag from the server
         // it should stop sending version since the version negotiation is done.
@@ -2758,7 +2758,7 @@
 }
 
 void QuicConnection::WriteQueuedPackets() {
-  DCHECK(!writer_->IsWriteBlocked());
+  QUICHE_DCHECK(!writer_->IsWriteBlocked());
 
   QUIC_CLIENT_HISTOGRAM_COUNTS("QuicSession.NumQueuedPacketsBeforeWrite",
                                buffered_packets_.size(), 1, 1000, 50, "");
@@ -2838,8 +2838,8 @@
 bool QuicConnection::ShouldGeneratePacket(
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
-  DCHECK(handshake != IS_HANDSHAKE ||
-         QuicVersionUsesCryptoFrames(transport_version()))
+  QUICHE_DCHECK(handshake != IS_HANDSHAKE ||
+                QuicVersionUsesCryptoFrames(transport_version()))
       << ENDPOINT
       << "Handshake in STREAM frames should not check ShouldGeneratePacket";
   if (!count_bytes_on_alternative_path_separately_) {
@@ -3002,7 +3002,7 @@
     termination_packets_->emplace_back(
         new QuicEncryptedPacket(buffer_copy, encrypted_length, true));
     if (error_code == QUIC_SILENT_IDLE_TIMEOUT) {
-      DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+      QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
       // TODO(fayang): populate histogram indicating the time elapsed from this
       // connection gets closed to following client packets get received.
       QUIC_DVLOG(1) << ENDPOINT
@@ -3013,9 +3013,9 @@
     }
   }
 
-  DCHECK_LE(encrypted_length, kMaxOutgoingPacketSize);
-  DCHECK(is_mtu_discovery ||
-         encrypted_length <= packet_creator_.max_packet_length())
+  QUICHE_DCHECK_LE(encrypted_length, kMaxOutgoingPacketSize);
+  QUICHE_DCHECK(is_mtu_discovery ||
+                encrypted_length <= packet_creator_.max_packet_length())
       << " encrypted_length=" << encrypted_length
       << " > packet_creator max_packet_length="
       << packet_creator_.max_packet_length();
@@ -3106,11 +3106,11 @@
       }
       break;
     case LEGACY_VERSION_ENCAPSULATE: {
-      DCHECK(!is_mtu_discovery);
-      DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-      DCHECK_EQ(packet->encryption_level, ENCRYPTION_INITIAL);
-      DCHECK(legacy_version_encapsulation_enabled_);
-      DCHECK(legacy_version_encapsulation_in_progress_);
+      QUICHE_DCHECK(!is_mtu_discovery);
+      QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+      QUICHE_DCHECK_EQ(packet->encryption_level, ENCRYPTION_INITIAL);
+      QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
+      QUICHE_DCHECK(legacy_version_encapsulation_in_progress_);
       QuicPacketLength encapsulated_length =
           QuicLegacyVersionEncapsulator::Encapsulate(
               legacy_version_encapsulation_sni_,
@@ -3149,7 +3149,7 @@
       }
     } break;
     default:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       break;
   }
 
@@ -3161,7 +3161,7 @@
   if (IsWriteBlockedStatus(result.status)) {
     // Ensure the writer is still write blocked, otherwise QUIC may continue
     // trying to write when it will not be able to.
-    DCHECK(writer_->IsWriteBlocked());
+    QUICHE_DCHECK(writer_->IsWriteBlocked());
     visitor_->OnWriteBlocked();
     // If the socket buffers the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
@@ -3453,7 +3453,7 @@
                       "QuicConnection::FlushPackets.");
 
   if (HandleWriteBlocked()) {
-    DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status)
+    QUICHE_DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status)
         << "Unexpected flush result:" << result;
     QUIC_DLOG(INFO) << ENDPOINT << "Write blocked in FlushPackets.";
     return;
@@ -3671,7 +3671,7 @@
 }
 
 void QuicConnection::SendAck() {
-  DCHECK(!SupportsMultiplePacketNumberSpaces());
+  QUICHE_DCHECK(!SupportsMultiplePacketNumberSpaces());
   QUIC_DVLOG(1) << ENDPOINT << "Sending an ACK proactively";
   QuicFrames frames;
   frames.push_back(GetUpdatedAckFrame());
@@ -3700,8 +3700,8 @@
 void QuicConnection::OnRetransmissionTimeout() {
 #ifndef NDEBUG
   if (sent_packet_manager_.unacked_packets().empty()) {
-    DCHECK(sent_packet_manager_.handshake_mode_disabled());
-    DCHECK(!IsHandshakeComplete());
+    QUICHE_DCHECK(sent_packet_manager_.handshake_mode_disabled());
+    QUICHE_DCHECK(!IsHandshakeComplete());
   }
 #endif
   if (!connected_) {
@@ -3732,7 +3732,7 @@
       !sent_packet_manager_.HasInFlightPackets() &&
       blackhole_detector_.IsDetectionInProgress()) {
     // Stop detection in quiescence.
-    DCHECK_EQ(QuicSentPacketManager::LOSS_MODE, retransmission_mode);
+    QUICHE_DCHECK_EQ(QuicSentPacketManager::LOSS_MODE, retransmission_mode);
     blackhole_detector_.StopDetection();
   }
   WriteIfNotBlocked();
@@ -3762,7 +3762,8 @@
     QUIC_DLOG(INFO) << ENDPOINT
                     << "No packet gets sent when timer fires in mode "
                     << retransmission_mode << ", send PING";
-    DCHECK_LT(0u, sent_packet_manager_.pending_timer_transmission_count());
+    QUICHE_DCHECK_LT(0u,
+                     sent_packet_manager_.pending_timer_transmission_count());
     EncryptionLevel level = encryption_level_;
     PacketNumberSpace packet_number_space = NUM_PACKET_NUMBER_SPACES;
     if (SupportsMultiplePacketNumberSpaces() &&
@@ -3813,7 +3814,7 @@
 
 void QuicConnection::SetDiversificationNonce(
     const DiversificationNonce& nonce) {
-  DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+  QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
   packet_creator_.SetDiversificationNonce(nonce);
 }
 
@@ -4043,7 +4044,7 @@
     QuicIetfTransportErrorCodes ietf_error,
     const std::string& error_details,
     ConnectionCloseBehavior connection_close_behavior) {
-  DCHECK(!error_details.empty());
+  QUICHE_DCHECK(!error_details.empty());
   if (!connected_) {
     QUIC_DLOG(INFO) << "Connection is already closed.";
     return;
@@ -4195,7 +4196,7 @@
   // If we are using a batch writer, flush packets queued in it, if any.
   FlushPackets();
   connected_ = false;
-  DCHECK(visitor_ != nullptr);
+  QUICHE_DCHECK(visitor_ != nullptr);
   visitor_->OnConnectionClosed(frame, source);
   // LossDetectionTunerInterface::Finish() may be called from
   // sent_packet_manager_.OnConnectionClosed. Which may require the session to
@@ -4285,12 +4286,12 @@
     }
     return;
   }
-  DCHECK_LT(initial_retransmittable_on_wire_timeout_, ping_timeout_);
+  QUICHE_DCHECK_LT(initial_retransmittable_on_wire_timeout_, ping_timeout_);
   QuicTime::Delta retransmittable_on_wire_timeout =
       initial_retransmittable_on_wire_timeout_;
   int max_aggressive_retransmittable_on_wire_ping_count =
       GetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count);
-  DCHECK_LE(0, max_aggressive_retransmittable_on_wire_ping_count);
+  QUICHE_DCHECK_LE(0, max_aggressive_retransmittable_on_wire_ping_count);
   if (consecutive_retransmittable_on_wire_ping_count_ >
       max_aggressive_retransmittable_on_wire_ping_count) {
     // Exponentially back off the timeout if the number of consecutive
@@ -4444,8 +4445,8 @@
       connection_->pending_retransmission_alarm_ = false;
     }
   }
-  DCHECK_EQ(flush_and_set_pending_retransmission_alarm_on_delete_,
-            !connection_->packet_creator_.PacketFlusherAttached());
+  QUICHE_DCHECK_EQ(flush_and_set_pending_retransmission_alarm_on_delete_,
+                   !connection_->packet_creator_.PacketFlusherAttached());
 }
 
 QuicConnection::ScopedEncryptionLevelContext::ScopedEncryptionLevelContext(
@@ -4544,7 +4545,7 @@
 
 void QuicConnection::SendMtuDiscoveryPacket(QuicByteCount target_mtu) {
   // Currently, this limit is ensured by the caller.
-  DCHECK_EQ(target_mtu, GetLimitedMaxPacketSize(target_mtu));
+  QUICHE_DCHECK_EQ(target_mtu, GetLimitedMaxPacketSize(target_mtu));
 
   // Send the probe.
   packet_creator_.GenerateMtuDiscoveryPacket(target_mtu);
@@ -4570,7 +4571,7 @@
     QuicPacketWriter* probing_writer,
     const QuicSocketAddress& peer_address,
     bool is_response) {
-  DCHECK(peer_address.IsInitialized());
+  QUICHE_DCHECK(peer_address.IsInitialized());
   if (!connected_) {
     QUIC_BUG << "Not sending connectivity probing packet as connection is "
              << "disconnected.";
@@ -4580,7 +4581,7 @@
     // Server can use default packet writer to write packet.
     probing_writer = writer_;
   }
-  DCHECK(probing_writer);
+  QUICHE_DCHECK(probing_writer);
 
   if (probing_writer->IsWriteBlocked()) {
     QUIC_DLOG(INFO)
@@ -4604,7 +4605,7 @@
     // request or a response.
     probing_packet = packet_creator_.SerializeConnectivityProbingPacket();
   } else if (is_response) {
-    DCHECK(!send_path_response_);
+    QUICHE_DCHECK(!send_path_response_);
     // IETF QUIC path response.
     // Respond to path probe request using IETF QUIC PATH_RESPONSE frame.
     probing_packet =
@@ -4626,7 +4627,7 @@
       transmitted_connectivity_probe_payload_ = nullptr;
     }
   }
-  DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
+  QUICHE_DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
   return WritePacketUsingWriter(std::move(probing_packet), probing_writer,
                                 self_address(), peer_address,
                                 /*measure_rtt=*/true);
@@ -4702,7 +4703,7 @@
 }
 
 void QuicConnection::DiscoverMtu() {
-  DCHECK(!mtu_discovery_alarm_->IsSet());
+  QUICHE_DCHECK(!mtu_discovery_alarm_->IsSet());
 
   const QuicPacketNumber largest_sent_packet =
       sent_packet_manager_.GetLargestSentPacket();
@@ -4711,7 +4712,7 @@
     SendMtuDiscoveryPacket(
         mtu_discoverer_.GetUpdatedMtuProbeSize(largest_sent_packet));
   }
-  DCHECK(!mtu_discovery_alarm_->IsSet());
+  QUICHE_DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 void QuicConnection::OnEffectivePeerMigrationValidated() {
@@ -4802,7 +4803,7 @@
 }
 
 void QuicConnection::MaybeSendProbingRetransmissions() {
-  DCHECK(fill_up_link_during_probing_);
+  QUICHE_DCHECK(fill_up_link_during_probing_);
 
   // Don't send probing retransmissions until the handshake has completed.
   if (!IsHandshakeComplete() ||
@@ -4938,7 +4939,7 @@
 }
 
 void QuicConnection::MaybeStartIetfPeerMigration() {
-  DCHECK(version().HasIetfQuicFrames());
+  QUICHE_DCHECK(version().HasIetfQuicFrames());
   if (!start_peer_migration_earlier_) {
     return;
   }
@@ -5021,7 +5022,7 @@
 }
 
 void QuicConnection::UpdateReleaseTimeIntoFuture() {
-  DCHECK(supports_release_time_);
+  QUICHE_DCHECK(supports_release_time_);
 
   const QuicTime::Delta prior_max_release_time = release_time_into_future_;
   release_time_into_future_ = std::max(
@@ -5100,7 +5101,7 @@
 }
 
 void QuicConnection::MaybeBundleCryptoDataWithAcks() {
-  DCHECK(SupportsMultiplePacketNumberSpaces());
+  QUICHE_DCHECK(SupportsMultiplePacketNumberSpaces());
   if (IsHandshakeConfirmed()) {
     return;
   }
@@ -5136,7 +5137,7 @@
 }
 
 void QuicConnection::SendAllPendingAcks() {
-  DCHECK(SupportsMultiplePacketNumberSpaces());
+  QUICHE_DCHECK(SupportsMultiplePacketNumberSpaces());
   QUIC_DVLOG(1) << ENDPOINT << "Trying to send all pending ACKs";
   ack_alarm_->Cancel();
   QuicTime earliest_ack_timeout =
@@ -5444,7 +5445,7 @@
     return DISCARD;
   }
   if (legacy_version_encapsulation_in_progress_) {
-    DCHECK(!is_mtu_discovery);
+    QUICHE_DCHECK(!is_mtu_discovery);
     return LEGACY_VERSION_ENCAPSULATE;
   }
   if (version().CanSendCoalescedPackets() && !coalescing_done_ &&
@@ -5471,7 +5472,7 @@
 }
 
 bool QuicConnection::IsHandshakeConfirmed() const {
-  DCHECK_EQ(PROTOCOL_TLS1_3, version().handshake_protocol);
+  QUICHE_DCHECK_EQ(PROTOCOL_TLS1_3, version().handshake_protocol);
   return visitor_->GetHandshakeState() == HANDSHAKE_CONFIRMED;
 }
 
@@ -5616,7 +5617,7 @@
   if (!ShouldDetectBlackhole()) {
     return QuicTime::Zero();
   }
-  DCHECK_LT(0u, num_rtos_for_blackhole_detection_);
+  QUICHE_DCHECK_LT(0u, num_rtos_for_blackhole_detection_);
   return clock_->ApproximateNow() +
          sent_packet_manager_.GetNetworkBlackholeDelay(
              num_rtos_for_blackhole_detection_);
@@ -5674,8 +5675,8 @@
   std::unique_ptr<SerializedPacket> probing_packet =
       packet_creator_.SerializePathChallengeConnectivityProbingPacket(
           data_buffer);
-  DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
-  DCHECK_EQ(self_address, most_recent_alternative_path_.self_address);
+  QUICHE_DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
+  QUICHE_DCHECK_EQ(self_address, most_recent_alternative_path_.self_address);
   WritePacketUsingWriter(std::move(probing_packet), writer, self_address,
                          peer_address, /*measure_rtt=*/false);
   return true;
@@ -5694,7 +5695,7 @@
 void QuicConnection::ValidatePath(
     std::unique_ptr<QuicPathValidationContext> context,
     std::unique_ptr<QuicPathValidator::ResultDelegate> result_delegate) {
-  DCHECK(use_path_validator_);
+  QUICHE_DCHECK(use_path_validator_);
   if (perspective_ == Perspective::IS_CLIENT &&
       !IsDefaultPath(context->self_address(), context->peer_address())) {
     most_recent_alternative_path_ =
@@ -5722,7 +5723,7 @@
     return packet_creator_.AddPathResponseFrame(data_buffer);
   }
 
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
   // This PATH_CHALLENGE is received on an alternative socket which should be
   // used to send PATH_RESPONSE.
   if (!path_validator_.HasPendingPathValidation() ||
@@ -5736,7 +5737,7 @@
   std::unique_ptr<SerializedPacket> probing_packet =
       packet_creator_.SerializePathResponseConnectivityProbingPacket(
           {data_buffer}, /*is_padded=*/true);
-  DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
+  QUICHE_DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
   QUIC_DVLOG(1) << ENDPOINT
                 << "Send PATH_RESPONSE from alternative socket with address "
                 << last_packet_destination_address_;
@@ -5760,17 +5761,17 @@
 }
 
 bool QuicConnection::HasPendingPathValidation() const {
-  DCHECK(use_path_validator_);
+  QUICHE_DCHECK(use_path_validator_);
   return path_validator_.HasPendingPathValidation();
 }
 
 QuicPathValidationContext* QuicConnection::GetPathValidationContext() const {
-  DCHECK(use_path_validator_);
+  QUICHE_DCHECK(use_path_validator_);
   return path_validator_.GetContext();
 }
 
 void QuicConnection::CancelPathValidation() {
-  DCHECK(use_path_validator_);
+  QUICHE_DCHECK(use_path_validator_);
   path_validator_.CancelPathValidation();
 }
 
@@ -5798,7 +5799,7 @@
 }
 
 void QuicConnection::SetSourceAddressTokenToSend(absl::string_view token) {
-  DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   if (!packet_creator_.HasRetryToken()) {
     // Ignore received tokens (via NEW_TOKEN frame) from previous connections
     // when a RETRY token has been received.
@@ -5813,7 +5814,7 @@
       perspective_ != Perspective::IS_SERVER) {
     return;
   }
-  DCHECK(!IsDefaultPath(self_address_, peer_address));
+  QUICHE_DCHECK(!IsDefaultPath(self_address_, peer_address));
   if (!IsMostRecentAlternativePath(self_address_, peer_address)) {
     QUIC_DLOG(INFO) << "Wrote to uninteresting peer address: " << peer_address
                     << " default direct_peer_address_ " << direct_peer_address_
@@ -5853,8 +5854,8 @@
   }
   // Only update bytes received if this probing frame is received on the most
   // recent alternative path.
-  DCHECK(!IsDefaultPath(last_packet_destination_address_,
-                        GetEffectivePeerAddressFromCurrentPacket()));
+  QUICHE_DCHECK(!IsDefaultPath(last_packet_destination_address_,
+                               GetEffectivePeerAddressFromCurrentPacket()));
   if (!most_recent_alternative_path_.validated) {
     most_recent_alternative_path_.bytes_received_before_address_validation +=
         received_packet_size;
diff --git a/quic/core/quic_connection_id.cc b/quic/core/quic_connection_id.cc
index ea8b936..303db8f 100644
--- a/quic/core/quic_connection_id.cc
+++ b/quic/core/quic_connection_id.cc
@@ -68,7 +68,7 @@
     return;
   }
   data_long_ = reinterpret_cast<char*>(malloc(length_));
-  CHECK_NE(nullptr, data_long_);
+  QUICHE_CHECK_NE(nullptr, data_long_);
   memcpy(data_long_, data, length_);
 }
 
@@ -113,13 +113,13 @@
       // Copy data from data_short_ to data_long_.
       memcpy(temporary_data, data_short_, length_);
       data_long_ = reinterpret_cast<char*>(malloc(length));
-      CHECK_NE(nullptr, data_long_);
+      QUICHE_CHECK_NE(nullptr, data_long_);
       memcpy(data_long_, temporary_data, length_);
     } else {
       // Resize data_long_.
       char* realloc_result =
           reinterpret_cast<char*>(realloc(data_long_, length));
-      CHECK_NE(nullptr, realloc_result);
+      QUICHE_CHECK_NE(nullptr, realloc_result);
       data_long_ = realloc_result;
     }
   } else if (length_ > sizeof(data_short_)) {
diff --git a/quic/core/quic_connection_id_manager.cc b/quic/core/quic_connection_id_manager.cc
index a4166ef..adf8eba 100644
--- a/quic/core/quic_connection_id_manager.cc
+++ b/quic/core/quic_connection_id_manager.cc
@@ -69,8 +69,8 @@
       clock_(clock),
       retire_connection_id_alarm_(alarm_factory->CreateAlarm(
           new RetirePeerIssuedConnectionIdAlarm(visitor))) {
-  DCHECK_GE(active_connection_id_limit_, 2u);
-  DCHECK(!initial_peer_issued_connection_id.IsEmpty());
+  QUICHE_DCHECK_GE(active_connection_id_limit_, 2u);
+  QUICHE_DCHECK(!initial_peer_issued_connection_id.IsEmpty());
   active_connection_id_data_.emplace_back(initial_peer_issued_connection_id,
                                           /*sequence_number=*/0u,
                                           QuicUint128());
@@ -294,7 +294,7 @@
 QuicNewConnectionIdFrame
 QuicSelfIssuedConnectionIdManager::IssueNewConnectionIdForPreferredAddress() {
   QuicNewConnectionIdFrame frame = IssueNewConnectionId();
-  DCHECK_EQ(frame.sequence_number, 1u);
+  QUICHE_DCHECK_EQ(frame.sequence_number, 1u);
   return frame;
 }
 
@@ -302,7 +302,7 @@
     const QuicRetireConnectionIdFrame& frame,
     QuicTime::Delta pto_delay,
     std::string* error_detail) {
-  DCHECK(!active_connection_ids_.empty());
+  QUICHE_DCHECK(!active_connection_ids_.empty());
   if (frame.sequence_number > active_connection_ids_.back().second) {
     *error_detail = "To be retired connecton ID is never issued.";
     return IETF_QUIC_PROTOCOL_VIOLATION;
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index a32d9e4..b3a3d13 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -105,10 +105,10 @@
     case ENCRYPTION_ZERO_RTT:
       return ZERO_RTT_PROTECTED;
     case ENCRYPTION_FORWARD_SECURE:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       return INVALID_PACKET_TYPE;
     default:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       return INVALID_PACKET_TYPE;
   }
 }
@@ -295,7 +295,7 @@
                                               QuicStreamOffset offset,
                                               StreamSendingState state) {
     ScopedPacketFlusher flusher(this);
-    DCHECK(encryption_level >= ENCRYPTION_ZERO_RTT);
+    QUICHE_DCHECK(encryption_level >= ENCRYPTION_ZERO_RTT);
     SetEncrypter(encryption_level, std::make_unique<TaggingEncrypter>(0x01));
     SetDefaultEncryptionLevel(encryption_level);
     struct iovec iov;
@@ -474,7 +474,7 @@
   }
 
   void PathDegradingTimeout() {
-    DCHECK(PathDegradingDetectionInProgress());
+    QUICHE_DCHECK(PathDegradingDetectionInProgress());
     GetBlackholeDetectorAlarm()->Fire();
   }
 
@@ -511,8 +511,8 @@
     if (QuicConnectionPeer::GetSentPacketManager(this)->pto_enabled()) {
       // PTO mode is default enabled for T099. And TLP/RTO related tests are
       // stale.
-      DCHECK(PROTOCOL_TLS1_3 == version().handshake_protocol ||
-             GetQuicReloadableFlag(quic_default_on_pto));
+      QUICHE_DCHECK(PROTOCOL_TLS1_3 == version().handshake_protocol ||
+                    GetQuicReloadableFlag(quic_default_on_pto));
       return true;
     }
     return false;
@@ -799,7 +799,7 @@
                                         QuicSocketAddress self_address,
                                         QuicSocketAddress peer_address,
                                         EncryptionLevel level) {
-    DCHECK(peer_framer_.HasEncrypterOfEncryptionLevel(level));
+    QUICHE_DCHECK(peer_framer_.HasEncrypterOfEncryptionLevel(level));
     peer_creator_.set_encryption_level(level);
     QuicPacketCreatorPeer::SetSendVersionInPacket(
         &peer_creator_,
@@ -835,14 +835,14 @@
     size_t length = peer_framer_.BuildDataPacket(
         header, frames, encrypted_buffer, kMaxOutgoingPacketSize,
         ENCRYPTION_INITIAL);
-    DCHECK_GT(length, 0u);
+    QUICHE_DCHECK_GT(length, 0u);
 
     const size_t encrypted_length = peer_framer_.EncryptInPlace(
         ENCRYPTION_INITIAL, header.packet_number,
         GetStartOfEncryptedData(peer_framer_.version().transport_version,
                                 header),
         length, kMaxOutgoingPacketSize, encrypted_buffer);
-    DCHECK_GT(encrypted_length, 0u);
+    QUICHE_DCHECK_GT(encrypted_length, 0u);
 
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
@@ -941,7 +941,8 @@
       size_t encrypted_length = peer_framer_.EncryptPayload(
           packet.level, QuicPacketNumber(packet.packet_number),
           *constructed_packet, buffer, kMaxOutgoingPacketSize);
-      DCHECK_LE(coalesced_size + encrypted_length, kMaxOutgoingPacketSize);
+      QUICHE_DCHECK_LE(coalesced_size + encrypted_length,
+                       kMaxOutgoingPacketSize);
       memcpy(coalesced_buffer + coalesced_size, buffer, encrypted_length);
       coalesced_size += encrypted_length;
     }
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index 31d67c3..64e5f5d 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -270,8 +270,8 @@
 
 bool QuicControlFrameManager::RetransmitControlFrame(const QuicFrame& frame,
                                                      TransmissionType type) {
-  DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
-         type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
+  QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
+                type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
   QuicControlFrameId id = GetControlFrameId(frame);
   if (id == kInvalidControlFrameId) {
     // Frame does not have a valid control frame ID, ignore it. Returns true
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc
index cebbc94..29a4367 100644
--- a/quic/core/quic_crypto_client_handshaker.cc
+++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -167,12 +167,12 @@
 }
 
 void QuicCryptoClientHandshaker::OnHandshakeDoneReceived() {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 void QuicCryptoClientHandshaker::OnNewTokenReceived(
     absl::string_view /*token*/) {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 size_t QuicCryptoClientHandshaker::BufferSizeLimitForLevel(
@@ -187,14 +187,14 @@
 std::unique_ptr<QuicDecrypter>
 QuicCryptoClientHandshaker::AdvanceKeysAndCreateCurrentOneRttDecrypter() {
   // Key update is only defined in QUIC+TLS.
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
 std::unique_ptr<QuicEncrypter>
 QuicCryptoClientHandshaker::CreateCurrentOneRttEncrypter() {
   // Key update is only defined in QUIC+TLS.
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
@@ -206,7 +206,7 @@
 
 void QuicCryptoClientHandshaker::HandleServerConfigUpdateMessage(
     const CryptoHandshakeMessage& server_config_update) {
-  DCHECK(server_config_update.tag() == kSCUP);
+  QUICHE_DCHECK(server_config_update.tag() == kSCUP);
   std::string error_details;
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_id_);
@@ -221,7 +221,7 @@
     return;
   }
 
-  DCHECK(one_rtt_keys_available());
+  QUICHE_DCHECK(one_rtt_keys_available());
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
@@ -236,7 +236,7 @@
 
   QuicAsyncStatus rv = QUIC_SUCCESS;
   do {
-    CHECK_NE(STATE_NONE, next_state_);
+    QUICHE_CHECK_NE(STATE_NONE, next_state_);
     const State state = next_state_;
     next_state_ = STATE_IDLE;
     rv = QUIC_SUCCESS;
@@ -284,7 +284,7 @@
     // This allows us to respond to CA trust changes or certificate
     // expiration because it may have been a while since we last verified
     // the proof.
-    DCHECK(crypto_config_->proof_verifier());
+    QUICHE_DCHECK(crypto_config_->proof_verifier());
     // Track proof verification time when cached server config is used.
     proof_verify_start_time_ = session()->connection()->clock()->Now();
     chlo_hash_ = cached->chlo_hash();
@@ -310,8 +310,8 @@
   num_client_hellos_++;
 
   CryptoHandshakeMessage out;
-  DCHECK(session() != nullptr);
-  DCHECK(session()->config() != nullptr);
+  QUICHE_DCHECK(session() != nullptr);
+  QUICHE_DCHECK(session()->config() != nullptr);
   // Send all the options, regardless of whether we're sending an
   // inchoate or subsequent hello.
   session()->config()->ToHandshakeMessage(&out, session()->transport_version());
@@ -463,7 +463,7 @@
 QuicAsyncStatus QuicCryptoClientHandshaker::DoVerifyProof(
     QuicCryptoClientConfig::CachedState* cached) {
   ProofVerifier* verifier = crypto_config_->proof_verifier();
-  DCHECK(verifier);
+  QUICHE_DCHECK(verifier);
   next_state_ = STATE_VERIFY_PROOF_COMPLETE;
   generation_counter_ = cached->generation_counter();
 
@@ -614,7 +614,7 @@
   bool update_ignored = false;
   if (!cached->IsEmpty() && !cached->signature().empty()) {
     // Note that we verify the proof even if the cached proof is valid.
-    DCHECK(crypto_config_->proof_verifier());
+    QUICHE_DCHECK(crypto_config_->proof_verifier());
     next_state_ = STATE_VERIFY_PROOF;
   } else {
     update_ignored = true;
diff --git a/quic/core/quic_crypto_client_stream.cc b/quic/core/quic_crypto_client_stream.cc
index 46af89a..3160f58 100644
--- a/quic/core/quic_crypto_client_stream.cc
+++ b/quic/core/quic_crypto_client_stream.cc
@@ -35,7 +35,8 @@
     ProofHandler* proof_handler,
     bool has_application_state)
     : QuicCryptoClientStreamBase(session) {
-  DCHECK_EQ(Perspective::IS_CLIENT, session->connection()->perspective());
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT,
+                   session->connection()->perspective());
   switch (session->connection()->version().handshake_protocol) {
     case PROTOCOL_QUIC_CRYPTO:
       handshaker_ = std::make_unique<QuicCryptoClientHandshaker>(
@@ -149,13 +150,13 @@
 }
 
 std::string QuicCryptoClientStream::GetAddressToken() const {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return "";
 }
 
 bool QuicCryptoClientStream::ValidateAddressToken(
     absl::string_view /*token*/) const {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return false;
 }
 
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index acf28b7..fc9be17 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -126,8 +126,8 @@
       CryptoUtils::HashHandshakeMessage(message, Perspective::IS_SERVER);
 
   std::unique_ptr<ValidateCallback> cb(new ValidateCallback(this));
-  DCHECK(validate_client_hello_cb_ == nullptr);
-  DCHECK(process_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(validate_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(process_client_hello_cb_ == nullptr);
   validate_client_hello_cb_ = cb.get();
   crypto_config_->ValidateClientHello(
       message, GetClientAddress(), session()->connection()->self_address(),
@@ -140,8 +140,8 @@
         result,
     std::unique_ptr<ProofSource::Details> details) {
   // Clear the callback that got us here.
-  DCHECK(validate_client_hello_cb_ != nullptr);
-  DCHECK(process_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(validate_client_hello_cb_ != nullptr);
+  QUICHE_DCHECK(process_client_hello_cb_ == nullptr);
   validate_client_hello_cb_ = nullptr;
 
   std::unique_ptr<ProcessClientHelloCallback> cb(
@@ -159,8 +159,8 @@
         std::unique_ptr<DiversificationNonce> diversification_nonce,
         std::unique_ptr<ProofSource::Details> proof_source_details) {
   // Clear the callback that got us here.
-  DCHECK(process_client_hello_cb_ != nullptr);
-  DCHECK(validate_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(process_client_hello_cb_ != nullptr);
+  QUICHE_DCHECK(validate_client_hello_cb_ == nullptr);
   process_client_hello_cb_ = nullptr;
   proof_source_details_ = std::move(proof_source_details);
 
@@ -276,7 +276,7 @@
     bool ok,
     const CryptoHandshakeMessage& message) {
   // Clear the callback that got us here.
-  DCHECK(send_server_config_update_cb_ != nullptr);
+  QUICHE_DCHECK(send_server_config_update_cb_ != nullptr);
   send_server_config_update_cb_ = nullptr;
 
   if (!ok) {
@@ -337,21 +337,21 @@
 }
 
 void QuicCryptoServerStream::OnHandshakeDoneReceived() {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 void QuicCryptoServerStream::OnNewTokenReceived(absl::string_view /*token*/) {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 std::string QuicCryptoServerStream::GetAddressToken() const {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return "";
 }
 
 bool QuicCryptoServerStream::ValidateAddressToken(
     absl::string_view /*token*/) const {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return false;
 }
 
@@ -428,14 +428,14 @@
 std::unique_ptr<QuicDecrypter>
 QuicCryptoServerStream::AdvanceKeysAndCreateCurrentOneRttDecrypter() {
   // Key update is only defined in QUIC+TLS.
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
 std::unique_ptr<QuicEncrypter>
 QuicCryptoServerStream::CreateCurrentOneRttEncrypter() {
   // Key update is only defined in QUIC+TLS.
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 1d5ff65..88fdda9 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -90,7 +90,7 @@
         helpers_.back().get(), alarm_factories_.back().get(),
         &server_crypto_config_, &server_compressed_certs_cache_,
         &server_connection_, &server_session);
-    CHECK(server_session);
+    QUICHE_CHECK(server_session);
     server_session_.reset(server_session);
     EXPECT_CALL(*server_session_->helper(), CanAcceptClientHello(_, _, _, _, _))
         .Times(testing::AnyNumber());
@@ -124,13 +124,13 @@
         server_id_, QuicTime::Delta::FromSeconds(100000), supported_versions_,
         helpers_.back().get(), alarm_factories_.back().get(),
         &client_crypto_config_, &client_connection_, &client_session);
-    CHECK(client_session);
+    QUICHE_CHECK(client_session);
     client_session_.reset(client_session);
   }
 
   int CompleteCryptoHandshake() {
-    CHECK(server_connection_);
-    CHECK(server_session_ != nullptr);
+    QUICHE_CHECK(server_connection_);
+    QUICHE_CHECK(server_session_ != nullptr);
 
     return crypto_test_utils::HandshakeWithFakeClient(
         helpers_.back().get(), alarm_factories_.back().get(),
@@ -141,8 +141,8 @@
   // Performs a single round of handshake message-exchange between the
   // client and server.
   void AdvanceHandshakeWithFakeClient() {
-    CHECK(server_connection_);
-    CHECK(client_session_ != nullptr);
+    QUICHE_CHECK(server_connection_);
+    QUICHE_CHECK(client_session_ != nullptr);
 
     EXPECT_CALL(*client_session_, OnProofValid(_)).Times(testing::AnyNumber());
     EXPECT_CALL(*client_session_, OnProofVerifyDetailsAvailable(_))
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index eccf4a3..1b2f6db 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -49,7 +49,8 @@
 QuicByteCount QuicCryptoStream::CryptoMessageFramingOverhead(
     QuicTransportVersion version,
     QuicConnectionId connection_id) {
-  DCHECK(QuicUtils::IsConnectionIdValidForVersion(connection_id, version));
+  QUICHE_DCHECK(
+      QuicUtils::IsConnectionIdValidForVersion(connection_id, version));
   QuicVariableLengthIntegerLength retry_token_length_length =
       VARIABLE_LENGTH_INTEGER_LENGTH_1;
   QuicVariableLengthIntegerLength length_length =
@@ -312,7 +313,7 @@
                                             QuicByteCount data_length,
                                             bool /*fin*/,
                                             TransmissionType type) {
-  DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
+  QUICHE_DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
   QuicIntervalSet<QuicStreamOffset> retransmission(offset,
                                                    offset + data_length);
   // Determine the encryption level to send data. This only needs to be once as
@@ -345,7 +346,7 @@
     QuicByteCount retransmission_length,
     EncryptionLevel encryption_level,
     TransmissionType type) {
-  DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
+  QUICHE_DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
   const auto consumed = stream_delegate()->WritevData(
       id(), retransmission_length, retransmission_offset, NO_FIN, type,
       encryption_level);
@@ -446,7 +447,8 @@
       << "Versions less than 47 don't use CRYPTO frames";
   for (EncryptionLevel level : AllEncryptionLevels()) {
     const QuicStreamSendBuffer& send_buffer = substreams_[level].send_buffer;
-    DCHECK_GE(send_buffer.stream_offset(), send_buffer.stream_bytes_written());
+    QUICHE_DCHECK_GE(send_buffer.stream_offset(),
+                     send_buffer.stream_bytes_written());
     if (send_buffer.stream_offset() > send_buffer.stream_bytes_written()) {
       return true;
     }
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc
index 761b92c..d15dd6e 100644
--- a/quic/core/quic_data_reader.cc
+++ b/quic/core/quic_data_reader.cc
@@ -45,16 +45,16 @@
   // After the fast pass, the exponent is at least one (offset by one).
   // Un-offset the exponent.
   --exponent;
-  DCHECK_GE(exponent, 1);
-  DCHECK_LE(exponent, kUFloat16MaxExponent);
+  QUICHE_DCHECK_GE(exponent, 1);
+  QUICHE_DCHECK_LE(exponent, kUFloat16MaxExponent);
   // Here we need to clear the exponent and set the hidden bit. We have already
   // decremented the exponent, so when we subtract it, it leaves behind the
   // hidden bit.
   *result -= exponent << kUFloat16MantissaBits;
   *result <<= exponent;
-  DCHECK_GE(*result,
-            static_cast<uint64_t>(1 << kUFloat16MantissaEffectiveBits));
-  DCHECK_LE(*result, kUFloat16MaxValue);
+  QUICHE_DCHECK_GE(*result,
+                   static_cast<uint64_t>(1 << kUFloat16MantissaEffectiveBits));
+  QUICHE_DCHECK_LE(*result, kUFloat16MaxValue);
   return true;
 }
 
@@ -72,7 +72,7 @@
   connection_id->set_length(length);
   const bool ok =
       ReadBytes(connection_id->mutable_data(), connection_id->length());
-  DCHECK(ok);
+  QUICHE_DCHECK(ok);
   return ok;
 }
 
@@ -86,7 +86,7 @@
 }
 
 QuicVariableLengthIntegerLength QuicDataReader::PeekVarInt62Length() {
-  DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+  QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
   const unsigned char* next =
       reinterpret_cast<const unsigned char*>(data() + pos());
   if (BytesRemaining() == 0) {
@@ -113,7 +113,7 @@
 // Low-level optimization is useful here because this function will be
 // called frequently, leading to outsize benefits.
 bool QuicDataReader::ReadVarInt62(uint64_t* result) {
-  DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+  QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
 
   size_t remaining = BytesRemaining();
   const unsigned char* next =
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index 78db03f..39cbc5a 100644
--- a/quic/core/quic_data_writer.cc
+++ b/quic/core/quic_data_writer.cc
@@ -52,10 +52,10 @@
       }
     }
 
-    DCHECK_GE(exponent, 1);
-    DCHECK_LE(exponent, kUFloat16MaxExponent);
-    DCHECK_GE(value, UINT64_C(1) << kUFloat16MantissaBits);
-    DCHECK_LT(value, UINT64_C(1) << kUFloat16MantissaEffectiveBits);
+    QUICHE_DCHECK_GE(exponent, 1);
+    QUICHE_DCHECK_LE(exponent, kUFloat16MaxExponent);
+    QUICHE_DCHECK_GE(value, UINT64_C(1) << kUFloat16MantissaBits);
+    QUICHE_DCHECK_LT(value, UINT64_C(1) << kUFloat16MantissaEffectiveBits);
 
     // Hidden bit (position 11) is set. We should remove it and increment the
     // exponent. Equivalently, we just add it to the exponent.
@@ -111,7 +111,7 @@
 // Low-level optimization is useful here because this function will be
 // called frequently, leading to outsize benefits.
 bool QuicDataWriter::WriteVarInt62(uint64_t value) {
-  DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+  QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
 
   size_t remaining_bytes = remaining();
   char* next = buffer() + length();
@@ -182,7 +182,7 @@
 bool QuicDataWriter::WriteVarInt62(
     uint64_t value,
     QuicVariableLengthIntegerLength write_length) {
-  DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+  QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
 
   size_t remaining_bytes = remaining();
   if (remaining_bytes < write_length) {
diff --git a/quic/core/quic_default_packet_writer.cc b/quic/core/quic_default_packet_writer.cc
index fe230d0..e71169a 100644
--- a/quic/core/quic_default_packet_writer.cc
+++ b/quic/core/quic_default_packet_writer.cc
@@ -19,8 +19,8 @@
     const QuicIpAddress& self_address,
     const QuicSocketAddress& peer_address,
     PerPacketOptions* options) {
-  DCHECK(!write_blocked_);
-  DCHECK(nullptr == options)
+  QUICHE_DCHECK(!write_blocked_);
+  QUICHE_DCHECK(nullptr == options)
       << "QuicDefaultPacketWriter does not accept any options.";
   QuicUdpPacketInfo packet_info;
   packet_info.SetPeerAddress(peer_address);
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 75f665a..d0d44b6 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -82,12 +82,12 @@
 
   bool ShouldGeneratePacket(HasRetransmittableData /*retransmittable*/,
                             IsHandshake /*handshake*/) override {
-    DCHECK(false);
+    QUICHE_DCHECK(false);
     return true;
   }
 
   const QuicFrames MaybeBundleAckOpportunistically() override {
-    DCHECK(false);
+    QUICHE_DCHECK(false);
     return {};
   }
 
@@ -181,7 +181,7 @@
       return;
     }
     creator_.FlushCurrentPacket();
-    DCHECK_EQ(1u, collector_.packets()->size());
+    QUICHE_DCHECK_EQ(1u, collector_.packets()->size());
   }
 
   QuicConnectionId server_connection_id_;
@@ -347,7 +347,7 @@
 }
 
 void QuicDispatcher::InitializeWithWriter(QuicPacketWriter* writer) {
-  DCHECK(writer_ == nullptr);
+  QUICHE_DCHECK(writer_ == nullptr);
   writer_.reset(writer);
   time_wait_list_manager_.reset(CreateQuicTimeWaitListManager());
 }
@@ -424,24 +424,27 @@
   if (server_connection_id_length == expected_server_connection_id_length_) {
     return server_connection_id;
   }
-  DCHECK(version.AllowsVariableLengthConnectionIds());
+  QUICHE_DCHECK(version.AllowsVariableLengthConnectionIds());
   QuicConnectionId new_connection_id;
   if (server_connection_id_length < expected_server_connection_id_length_) {
     new_connection_id = ReplaceShortServerConnectionId(
         version, server_connection_id, expected_server_connection_id_length_);
     // Verify that ReplaceShortServerConnectionId is deterministic.
-    DCHECK_EQ(new_connection_id, ReplaceShortServerConnectionId(
-                                     version, server_connection_id,
-                                     expected_server_connection_id_length_));
+    QUICHE_DCHECK_EQ(
+        new_connection_id,
+        ReplaceShortServerConnectionId(version, server_connection_id,
+                                       expected_server_connection_id_length_));
   } else {
     new_connection_id = ReplaceLongServerConnectionId(
         version, server_connection_id, expected_server_connection_id_length_);
     // Verify that ReplaceLongServerConnectionId is deterministic.
-    DCHECK_EQ(new_connection_id, ReplaceLongServerConnectionId(
-                                     version, server_connection_id,
-                                     expected_server_connection_id_length_));
+    QUICHE_DCHECK_EQ(
+        new_connection_id,
+        ReplaceLongServerConnectionId(version, server_connection_id,
+                                      expected_server_connection_id_length_));
   }
-  DCHECK_EQ(expected_server_connection_id_length_, new_connection_id.length());
+  QUICHE_DCHECK_EQ(expected_server_connection_id_length_,
+                   new_connection_id.length());
 
   QUIC_DLOG(INFO) << "Replacing incoming connection ID " << server_connection_id
                   << " with " << new_connection_id;
@@ -452,8 +455,8 @@
     const ParsedQuicVersion& /*version*/,
     const QuicConnectionId& server_connection_id,
     uint8_t expected_server_connection_id_length) const {
-  DCHECK_LT(server_connection_id.length(),
-            expected_server_connection_id_length);
+  QUICHE_DCHECK_LT(server_connection_id.length(),
+                   expected_server_connection_id_length);
   return QuicUtils::CreateReplacementConnectionId(
       server_connection_id, expected_server_connection_id_length);
 }
@@ -462,8 +465,8 @@
     const ParsedQuicVersion& /*version*/,
     const QuicConnectionId& server_connection_id,
     uint8_t expected_server_connection_id_length) const {
-  DCHECK_GT(server_connection_id.length(),
-            expected_server_connection_id_length);
+  QUICHE_DCHECK_GT(server_connection_id.length(),
+                   expected_server_connection_id_length);
   return QuicUtils::CreateReplacementConnectionId(
       server_connection_id, expected_server_connection_id_length);
 }
@@ -490,8 +493,8 @@
       server_connection_id.length() < kQuicMinimumInitialConnectionIdLength &&
       server_connection_id.length() < expected_server_connection_id_length_ &&
       !allow_short_initial_server_connection_ids_) {
-    DCHECK(packet_info.version_flag);
-    DCHECK(packet_info.version.AllowsVariableLengthConnectionIds());
+    QUICHE_DCHECK(packet_info.version_flag);
+    QUICHE_DCHECK(packet_info.version.AllowsVariableLengthConnectionIds());
     QUIC_DLOG(INFO) << "Packet with short destination connection ID "
                     << server_connection_id << " expected "
                     << static_cast<int>(expected_server_connection_id_length_);
@@ -505,7 +508,8 @@
   if (use_reference_counted_session_map_) {
     auto it = reference_counted_session_map_.find(server_connection_id);
     if (it != reference_counted_session_map_.end()) {
-      DCHECK(!buffered_packets_.HasBufferedPackets(server_connection_id));
+      QUICHE_DCHECK(
+          !buffered_packets_.HasBufferedPackets(server_connection_id));
       if (packet_info.version_flag &&
           packet_info.version != it->second->version() &&
           packet_info.version == LegacyVersionForEncapsulation()) {
@@ -530,7 +534,8 @@
   } else {
     auto it = session_map_.find(server_connection_id);
     if (it != session_map_.end()) {
-      DCHECK(!buffered_packets_.HasBufferedPackets(server_connection_id));
+      QUICHE_DCHECK(
+          !buffered_packets_.HasBufferedPackets(server_connection_id));
       if (packet_info.version_flag &&
           packet_info.version != it->second->version() &&
           packet_info.version == LegacyVersionForEncapsulation()) {
@@ -567,7 +572,8 @@
         // Search for the replacement.
         auto it2 = reference_counted_session_map_.find(replaced_connection_id);
         if (it2 != reference_counted_session_map_.end()) {
-          DCHECK(!buffered_packets_.HasBufferedPackets(replaced_connection_id));
+          QUICHE_DCHECK(
+              !buffered_packets_.HasBufferedPackets(replaced_connection_id));
           it2->second->ProcessUdpPacket(packet_info.self_address,
                                         packet_info.peer_address,
                                         packet_info.packet);
@@ -577,7 +583,8 @@
         // Search for the replacement.
         auto it2 = session_map_.find(replaced_connection_id);
         if (it2 != session_map_.end()) {
-          DCHECK(!buffered_packets_.HasBufferedPackets(replaced_connection_id));
+          QUICHE_DCHECK(
+              !buffered_packets_.HasBufferedPackets(replaced_connection_id));
           it2->second->ProcessUdpPacket(packet_info.self_address,
                                         packet_info.peer_address,
                                         packet_info.packet);
@@ -748,7 +755,7 @@
           QUIC_HANDSHAKE_FAILED, "Reject connection",
           quic::QuicTimeWaitListManager::SEND_STATELESS_RESET);
 
-      DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(
+      QUICHE_DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(
           server_connection_id));
       time_wait_list_manager_->ProcessPacket(
           packet_info->self_address, packet_info->peer_address,
@@ -884,7 +891,7 @@
 // Get a snapshot of all sessions.
 std::vector<std::shared_ptr<QuicSession>> QuicDispatcher::GetSessionsSnapshot()
     const {
-  DCHECK(use_reference_counted_session_map_);
+  QUICHE_DCHECK(use_reference_counted_session_map_);
   std::vector<std::shared_ptr<QuicSession>> snapshot;
   snapshot.reserve(reference_counted_session_map_.size());
   absl::flat_hash_set<QuicSession*> visited_session;
@@ -937,7 +944,7 @@
   const size_t num_blocked_writers_before = write_blocked_list_.size();
   WriteBlockedList temp_list;
   temp_list.swap(write_blocked_list_);
-  DCHECK(write_blocked_list_.empty());
+  QUICHE_DCHECK(write_blocked_list_.empty());
 
   // Give each blocked writer a chance to write what they indended to write.
   // If they are blocked again, they will call |OnWriteBlocked| to add
@@ -970,8 +977,9 @@
           QUIC_PEER_GOING_AWAY, "Server shutdown imminent",
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       // Validate that the session removes itself from the session map on close.
-      DCHECK(reference_counted_session_map_.empty() ||
-             reference_counted_session_map_.begin()->second.get() != session);
+      QUICHE_DCHECK(reference_counted_session_map_.empty() ||
+                    reference_counted_session_map_.begin()->second.get() !=
+                        session);
     }
   } else {
     while (!session_map_.empty()) {
@@ -980,8 +988,8 @@
           QUIC_PEER_GOING_AWAY, "Server shutdown imminent",
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       // Validate that the session removes itself from the session map on close.
-      DCHECK(session_map_.empty() ||
-             session_map_.begin()->second.get() != session);
+      QUICHE_DCHECK(session_map_.empty() ||
+                    session_map_.begin()->second.get() != session);
     }
   }
   DeleteSessions();
@@ -1062,7 +1070,7 @@
     QuicBlockedWriterInterface* blocked_writer) {
   if (!blocked_writer->IsWriterBlocked()) {
     // It is a programming error if this ever happens. When we are sure it is
-    // not happening, replace it with a DCHECK.
+    // not happening, replace it with a QUICHE_DCHECK.
     QUIC_BUG
         << "Tried to add writer into blocked list when it shouldn't be added";
     // Return without adding the connection to the blocked list, to avoid
@@ -1081,7 +1089,7 @@
 void QuicDispatcher::OnNewConnectionIdSent(
     const QuicConnectionId& server_connection_id,
     const QuicConnectionId& new_connection_id) {
-  DCHECK(support_multiple_cid_per_connection_);
+  QUICHE_DCHECK(support_multiple_cid_per_connection_);
   auto it = reference_counted_session_map_.find(server_connection_id);
   if (it == reference_counted_session_map_.end()) {
     QUIC_BUG << "Couldn't locate the session that issues the connection ID in "
@@ -1092,12 +1100,12 @@
   }
   auto insertion_result = reference_counted_session_map_.insert(
       std::make_pair(new_connection_id, it->second));
-  DCHECK(insertion_result.second);
+  QUICHE_DCHECK(insertion_result.second);
 }
 
 void QuicDispatcher::OnConnectionIdRetired(
     const QuicConnectionId& server_connection_id) {
-  DCHECK(support_multiple_cid_per_connection_);
+  QUICHE_DCHECK(support_multiple_cid_per_connection_);
   reference_counted_session_map_.erase(server_connection_id);
 }
 
@@ -1405,7 +1413,7 @@
 
 void QuicDispatcher::MaybeResetPacketsWithNoVersion(
     const ReceivedPacketInfo& packet_info) {
-  DCHECK(!packet_info.version_flag);
+  QUICHE_DCHECK(!packet_info.version_flag);
   const size_t MinValidPacketLength =
       kPacketHeaderTypeSize + expected_server_connection_id_length_ +
       PACKET_1BYTE_PACKET_NUMBER + /*payload size=*/1 + /*tag size=*/12;
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index ba2c6ea..26742d7 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -198,7 +198,7 @@
   void RetireConnectionId(QuicConnectionId id) {
     auto it = std::find(active_connection_ids_.begin(),
                         active_connection_ids_.end(), id);
-    DCHECK(it != active_connection_ids_.end());
+    QUICHE_DCHECK(it != active_connection_ids_.end());
     dispatcher_->OnConnectionIdRetired(id);
     active_connection_ids_.erase(it);
   }
@@ -800,9 +800,9 @@
   std::string chlo = SerializeCHLO() + std::string(1200, 'a');
   // Truncate to 1100 bytes of payload which results in a packet just
   // under 1200 bytes after framing, packet, and encryption overhead.
-  DCHECK_LE(1200u, chlo.length());
+  QUICHE_DCHECK_LE(1200u, chlo.length());
   std::string truncated_chlo = chlo.substr(0, 1100);
-  DCHECK_EQ(1100u, truncated_chlo.length());
+  QUICHE_DCHECK_EQ(1100u, truncated_chlo.length());
   ProcessPacket(client_address, TestConnectionId(1), true,
                 QuicVersionReservedForNegotiation(), truncated_chlo, false,
                 CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
@@ -824,9 +824,9 @@
   std::string chlo = SerializeCHLO() + std::string(1200, 'a');
   // Truncate to 1100 bytes of payload which results in a packet just
   // under 1200 bytes after framing, packet, and encryption overhead.
-  DCHECK_LE(1200u, chlo.length());
+  QUICHE_DCHECK_LE(1200u, chlo.length());
   std::string truncated_chlo = chlo.substr(0, 1100);
-  DCHECK_EQ(1100u, truncated_chlo.length());
+  QUICHE_DCHECK_EQ(1100u, truncated_chlo.length());
   ProcessPacket(client_address, TestConnectionId(1), true,
                 QuicVersionReservedForNegotiation(), truncated_chlo, true,
                 CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
diff --git a/quic/core/quic_epoll_alarm_factory.cc b/quic/core/quic_epoll_alarm_factory.cc
index 9f39f82..2a08868 100644
--- a/quic/core/quic_epoll_alarm_factory.cc
+++ b/quic/core/quic_epoll_alarm_factory.cc
@@ -21,18 +21,18 @@
 
  protected:
   void SetImpl() override {
-    DCHECK(deadline().IsInitialized());
+    QUICHE_DCHECK(deadline().IsInitialized());
     epoll_server_->RegisterAlarm(
         (deadline() - QuicTime::Zero()).ToMicroseconds(), &epoll_alarm_impl_);
   }
 
   void CancelImpl() override {
-    DCHECK(!deadline().IsInitialized());
+    QUICHE_DCHECK(!deadline().IsInitialized());
     epoll_alarm_impl_.UnregisterIfRegistered();
   }
 
   void UpdateImpl() override {
-    DCHECK(deadline().IsInitialized());
+    QUICHE_DCHECK(deadline().IsInitialized());
     int64_t epoll_deadline = (deadline() - QuicTime::Zero()).ToMicroseconds();
     if (epoll_alarm_impl_.registered()) {
       epoll_alarm_impl_.ReregisterAlarm(epoll_deadline);
diff --git a/quic/core/quic_epoll_connection_helper.cc b/quic/core/quic_epoll_connection_helper.cc
index f44566f..8f53256 100644
--- a/quic/core/quic_epoll_connection_helper.cc
+++ b/quic/core/quic_epoll_connection_helper.cc
@@ -32,7 +32,7 @@
   if (allocator_type_ == QuicAllocator::BUFFER_POOL) {
     return &stream_buffer_allocator_;
   } else {
-    DCHECK(allocator_type_ == QuicAllocator::SIMPLE);
+    QUICHE_DCHECK(allocator_type_ == QuicAllocator::SIMPLE);
     return &simple_buffer_allocator_;
   }
 }
diff --git a/quic/core/quic_error_codes.cc b/quic/core/quic_error_codes.cc
index cc050dd..dd8be33 100644
--- a/quic/core/quic_error_codes.cc
+++ b/quic/core/quic_error_codes.cc
@@ -313,7 +313,7 @@
     // change behavior and are only here to make the compiler happy.
     case CRYPTO_ERROR_FIRST:
     case CRYPTO_ERROR_LAST:
-      DCHECK(false) << "Unexpected error " << static_cast<uint64_t>(c);
+      QUICHE_DCHECK(false) << "Unexpected error " << static_cast<uint64_t>(c);
       break;
   }
 
diff --git a/quic/core/quic_flow_controller.cc b/quic/core/quic_flow_controller.cc
index b8bbda2..01fb72c 100644
--- a/quic/core/quic_flow_controller.cc
+++ b/quic/core/quic_flow_controller.cc
@@ -53,8 +53,8 @@
       session_flow_controller_(session_flow_controller),
       last_blocked_send_window_offset_(0),
       prev_window_update_time_(QuicTime::Zero()) {
-  DCHECK_LE(receive_window_size_, receive_window_size_limit_);
-  DCHECK_EQ(
+  QUICHE_DCHECK_LE(receive_window_size_, receive_window_size_limit_);
+  QUICHE_DCHECK_EQ(
       is_connection_flow_controller_,
       QuicUtils::GetInvalidStreamId(session_->transport_version()) == id_);
 
@@ -198,7 +198,7 @@
   // Send WindowUpdate to increase receive window if
   // (receive window offset - consumed bytes) < (max window / 2).
   // This is behaviour copied from SPDY.
-  DCHECK_LE(bytes_consumed_, receive_window_offset_);
+  QUICHE_DCHECK_LE(bytes_consumed_, receive_window_offset_);
   QuicStreamOffset available_window = receive_window_offset_ - bytes_consumed_;
   QuicByteCount threshold = WindowUpdateThreshold();
 
@@ -294,7 +294,7 @@
 }
 
 void QuicFlowController::UpdateReceiveWindowSize(QuicStreamOffset size) {
-  DCHECK_LE(size, receive_window_size_limit_);
+  QUICHE_DCHECK_LE(size, receive_window_size_limit_);
   QUIC_DVLOG(1) << ENDPOINT << "UpdateReceiveWindowSize for " << LogLabel()
                 << ": " << size;
   if (receive_window_size_ != receive_window_offset_) {
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index af85f12..60f069c 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -194,7 +194,7 @@
 }
 
 QuicPacketNumberLength GetShortHeaderPacketNumberLength(uint8_t type) {
-  DCHECK(!(type & FLAGS_LONG_HEADER));
+  QUICHE_DCHECK(!(type & FLAGS_LONG_HEADER));
   return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
 }
 
@@ -217,7 +217,7 @@
 }
 
 bool GetLongHeaderType(uint8_t type, QuicLongHeaderType* long_header_type) {
-  DCHECK((type & FLAGS_LONG_HEADER));
+  QUICHE_DCHECK((type & FLAGS_LONG_HEADER));
   switch ((type & 0x30) >> 4) {
     case 0:
       *long_header_type = INITIAL;
@@ -429,9 +429,9 @@
       peer_ack_delay_exponent_(kDefaultAckDelayExponent),
       local_ack_delay_exponent_(kDefaultAckDelayExponent),
       current_received_frame_type_(0) {
-  DCHECK(!supported_versions.empty());
+  QUICHE_DCHECK(!supported_versions.empty());
   version_ = supported_versions_[0];
-  DCHECK(version_.IsKnown())
+  QUICHE_DCHECK(version_.IsKnown())
       << ParsedQuicVersionVectorToString(supported_versions_);
 }
 
@@ -704,12 +704,12 @@
     case MESSAGE_FRAME:
     case CRYPTO_FRAME:
     case NUM_FRAME_TYPES:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       return 0;
   }
 
   // Not reachable, but some Chrome compilers can't figure that out.  *sigh*
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return 0;
 }
 
@@ -1310,7 +1310,7 @@
     const ParsedQuicVersionVector& versions) {
   QUIC_CODE_COUNT(quic_build_version_negotiation);
   if (use_length_prefix) {
-    DCHECK(ietf_quic);
+    QUICHE_DCHECK(ietf_quic);
     QUIC_CODE_COUNT(quic_build_version_negotiation_ietf);
   } else if (ietf_quic) {
     QUIC_CODE_COUNT(quic_build_version_negotiation_old_ietf);
@@ -1346,11 +1346,11 @@
   }
 
   // The GQUIC encoding does not support encoding client connection IDs.
-  DCHECK(client_connection_id.IsEmpty());
+  QUICHE_DCHECK(client_connection_id.IsEmpty());
   // The GQUIC encoding does not support length-prefixed connection IDs.
-  DCHECK(!use_length_prefix);
+  QUICHE_DCHECK(!use_length_prefix);
 
-  DCHECK(!wire_versions.empty());
+  QUICHE_DCHECK(!wire_versions.empty());
   size_t len = kPublicFlagsSize + server_connection_id.length() +
                wire_versions.size() * kQuicVersionSize;
   std::unique_ptr<char[]> buffer(new char[len]);
@@ -1389,7 +1389,7 @@
                 << server_connection_id << " client_connection_id "
                 << client_connection_id << " versions "
                 << ParsedQuicVersionVectorToString(versions);
-  DCHECK(!versions.empty());
+  QUICHE_DCHECK(!versions.empty());
   size_t len = kPacketHeaderTypeSize + kConnectionIdLengthSize +
                client_connection_id.length() + server_connection_id.length() +
                (versions.size() + 1) * kQuicVersionSize;
@@ -1450,10 +1450,10 @@
 
   QuicPacketHeader header;
   if (!ProcessPublicHeader(&reader, packet_has_ietf_packet_header, &header)) {
-    DCHECK_NE("", detailed_error_);
+    QUICHE_DCHECK_NE("", detailed_error_);
     QUIC_DVLOG(1) << ENDPOINT << "Unable to process public header. Error: "
                   << detailed_error_;
-    DCHECK_NE("", detailed_error_);
+    QUICHE_DCHECK_NE("", detailed_error_);
     RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_HEADER);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
@@ -1526,7 +1526,7 @@
 bool QuicFramer::ProcessVersionNegotiationPacket(
     QuicDataReader* reader,
     const QuicPacketHeader& header) {
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
 
   QuicVersionNegotiationPacket packet(
       GetServerConnectionIdAsRecipient(header, perspective_));
@@ -1554,14 +1554,14 @@
 
 bool QuicFramer::ProcessRetryPacket(QuicDataReader* reader,
                                     const QuicPacketHeader& header) {
-  DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
+  QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
   if (drop_incoming_retry_packets_) {
     QUIC_DLOG(INFO) << "Ignoring received RETRY packet";
     return true;
   }
 
   if (version_.UsesTls()) {
-    DCHECK(version_.HasLengthPrefixedConnectionIds()) << version_;
+    QUICHE_DCHECK(version_.HasLengthPrefixedConnectionIds()) << version_;
     const size_t bytes_remaining = reader->BytesRemaining();
     if (bytes_remaining <= kRetryIntegrityTagLength) {
       set_detailed_error("Retry packet too short to parse integrity tag.");
@@ -1569,7 +1569,7 @@
     }
     const size_t retry_token_length =
         bytes_remaining - kRetryIntegrityTagLength;
-    DCHECK_GT(retry_token_length, 0u);
+    QUICHE_DCHECK_GT(retry_token_length, 0u);
     absl::string_view retry_token;
     if (!reader->ReadStringPiece(&retry_token, retry_token_length)) {
       set_detailed_error("Failed to read retry token.");
@@ -1577,7 +1577,7 @@
     }
     absl::string_view retry_without_tag = reader->PreviouslyReadPayload();
     absl::string_view integrity_tag = reader->ReadRemainingPayload();
-    DCHECK_EQ(integrity_tag.length(), kRetryIntegrityTagLength);
+    QUICHE_DCHECK_EQ(integrity_tag.length(), kRetryIntegrityTagLength);
     visitor_->OnRetryPacket(EmptyQuicConnectionId(),
                             header.source_connection_id, retry_token,
                             integrity_tag, retry_without_tag);
@@ -1634,7 +1634,7 @@
   }
 
   absl::string_view remaining_data = encrypted_reader.PeekRemainingPayload();
-  DCHECK_EQ(remaining_data.length(), remaining_bytes_length);
+  QUICHE_DCHECK_EQ(remaining_data.length(), remaining_bytes_length);
 
   const char* coalesced_data =
       remaining_data.data() + header.remaining_packet_length;
@@ -1708,8 +1708,8 @@
                                        const QuicEncryptedPacket& packet,
                                        char* decrypted_buffer,
                                        size_t buffer_length) {
-  DCHECK_NE(GOOGLE_QUIC_PACKET, header->form);
-  DCHECK(!header->has_possible_stateless_reset_token);
+  QUICHE_DCHECK_NE(GOOGLE_QUIC_PACKET, header->form);
+  QUICHE_DCHECK(!header->has_possible_stateless_reset_token);
   header->length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
   header->remaining_packet_length = 0;
   if (header->form == IETF_QUIC_SHORT_HEADER_PACKET &&
@@ -1735,10 +1735,10 @@
   QuicPacketNumber base_packet_number;
   if (header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
       header->long_packet_type != VERSION_NEGOTIATION) {
-    DCHECK(header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
-           header->long_packet_type == INITIAL ||
-           header->long_packet_type == HANDSHAKE ||
-           header->long_packet_type == ZERO_RTT_PROTECTED);
+    QUICHE_DCHECK(header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
+                  header->long_packet_type == INITIAL ||
+                  header->long_packet_type == HANDSHAKE ||
+                  header->long_packet_type == ZERO_RTT_PROTECTED);
     // Process packet number.
     if (supports_multiple_packet_number_spaces_) {
       PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
@@ -1889,8 +1889,9 @@
     current_received_frame_type_ = 0;
     if (!ProcessIetfFrameData(&reader, *header)) {
       current_received_frame_type_ = 0;
-      DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessIetfFrameData sets the error.
-      DCHECK_NE("", detailed_error_);
+      QUICHE_DCHECK_NE(QUIC_NO_ERROR,
+                       error_);  // ProcessIetfFrameData sets the error.
+      QUICHE_DCHECK_NE("", detailed_error_);
       QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
                          << detailed_error_;
       return false;
@@ -1898,8 +1899,9 @@
     current_received_frame_type_ = 0;
   } else {
     if (!ProcessFrameData(&reader, *header)) {
-      DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
-      DCHECK_NE("", detailed_error_);
+      QUICHE_DCHECK_NE(QUIC_NO_ERROR,
+                       error_);  // ProcessFrameData sets the error.
+      QUICHE_DCHECK_NE("", detailed_error_);
       QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
                          << detailed_error_;
       return false;
@@ -1916,7 +1918,7 @@
                                    char* decrypted_buffer,
                                    size_t buffer_length) {
   if (!ProcessUnauthenticatedHeader(encrypted_reader, header)) {
-    DCHECK_NE("", detailed_error_);
+    QUICHE_DCHECK_NE("", detailed_error_);
     QUIC_DVLOG(1)
         << ENDPOINT
         << "Unable to process packet header. Stopping parsing. Error: "
@@ -1977,8 +1979,9 @@
 
   // Handle the payload.
   if (!ProcessFrameData(&reader, *header)) {
-    DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
-    DCHECK_NE("", detailed_error_);
+    QUICHE_DCHECK_NE(QUIC_NO_ERROR,
+                     error_);  // ProcessFrameData sets the error.
+    QUICHE_DCHECK_NE("", detailed_error_);
     QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
                        << detailed_error_;
     return false;
@@ -2079,7 +2082,7 @@
   if (HasEncrypterOfEncryptionLevel(ENCRYPTION_FORWARD_SECURE)) {
     return ENCRYPTION_FORWARD_SECURE;
   }
-  DCHECK(HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT));
+  QUICHE_DCHECK(HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT));
   return ENCRYPTION_ZERO_RTT;
 }
 
@@ -2102,7 +2105,7 @@
                   << kPublicHeaderSequenceNumberShift;
 
   if (header.nonce != nullptr) {
-    DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
     public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
   }
 
@@ -2110,8 +2113,8 @@
       GetServerConnectionIdAsSender(header, perspective_);
   QuicConnectionIdIncluded server_connection_id_included =
       GetServerConnectionIdIncludedAsSender(header, perspective_);
-  DCHECK_EQ(CONNECTION_ID_ABSENT,
-            GetClientConnectionIdIncludedAsSender(header, perspective_))
+  QUICHE_DCHECK_EQ(CONNECTION_ID_ABSENT,
+                   GetClientConnectionIdIncludedAsSender(header, perspective_))
       << ENDPOINT << ParsedQuicVersionToString(version_)
       << " invalid header: " << header;
 
@@ -2142,7 +2145,7 @@
   last_serialized_server_connection_id_ = server_connection_id;
 
   if (header.version_flag) {
-    DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
+    QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
     QuicVersionLabel version_label = CreateQuicVersionLabel(version_);
     if (!writer->WriteUInt32(version_label)) {
       return false;
@@ -2196,7 +2199,7 @@
   }
 
   if (header.version_flag) {
-    DCHECK_NE(VERSION_NEGOTIATION, header.long_packet_type)
+    QUICHE_DCHECK_NE(VERSION_NEGOTIATION, header.long_packet_type)
         << "QuicFramer::AppendIetfPacketHeader does not support sending "
            "version negotiation packets, use "
            "QuicFramer::BuildVersionNegotiationPacket instead "
@@ -2234,8 +2237,8 @@
   if (QuicVersionHasLongHeaderLengths(transport_version()) &&
       header.version_flag) {
     if (header.long_packet_type == INITIAL) {
-      DCHECK_NE(VARIABLE_LENGTH_INTEGER_LENGTH_0,
-                header.retry_token_length_length)
+      QUICHE_DCHECK_NE(VARIABLE_LENGTH_INTEGER_LENGTH_0,
+                       header.retry_token_length_length)
           << ENDPOINT << ParsedQuicVersionToString(version_)
           << " bad retry token length length in header: " << header;
       // Write retry token length.
@@ -2270,9 +2273,9 @@
   }
 
   if (header.nonce != nullptr) {
-    DCHECK(header.version_flag);
-    DCHECK_EQ(ZERO_RTT_PROTECTED, header.long_packet_type);
-    DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+    QUICHE_DCHECK(header.version_flag);
+    QUICHE_DCHECK_EQ(ZERO_RTT_PROTECTED, header.long_packet_type);
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
     if (!writer->WriteBytes(header.nonce, kDiversificationNonceSize)) {
       return false;
     }
@@ -2424,7 +2427,7 @@
 // static
 QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
     QuicPacketNumber packet_number) {
-  DCHECK(packet_number.IsInitialized());
+  QUICHE_DCHECK(packet_number.IsInitialized());
   if (packet_number < QuicPacketNumber(1 << (PACKET_1BYTE_PACKET_NUMBER * 8))) {
     return PACKET_1BYTE_PACKET_NUMBER;
   } else if (packet_number <
@@ -2729,7 +2732,7 @@
     header->source_connection_id_included =
         header->version_flag ? CONNECTION_ID_PRESENT : CONNECTION_ID_ABSENT;
     if (header->source_connection_id_included == CONNECTION_ID_ABSENT) {
-      DCHECK(header->source_connection_id.IsEmpty());
+      QUICHE_DCHECK(header->source_connection_id.IsEmpty());
       if (perspective_ == Perspective::IS_CLIENT) {
         header->source_connection_id = last_serialized_server_connection_id_;
       } else {
@@ -2819,7 +2822,7 @@
 
   if (header->source_connection_id_included == CONNECTION_ID_ABSENT) {
     if (!header->source_connection_id.IsEmpty()) {
-      DCHECK(!version_.SupportsClientConnectionIds());
+      QUICHE_DCHECK(!version_.SupportsClientConnectionIds());
       set_detailed_error("Client connection ID not supported in this version.");
       return false;
     }
@@ -2852,7 +2855,7 @@
 
 bool QuicFramer::ProcessFrameData(QuicDataReader* reader,
                                   const QuicPacketHeader& header) {
-  DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
+  QUICHE_DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
       << "IETF QUIC Framing negotiated but attempting to process frames as "
          "non-IETF QUIC.";
   if (reader->IsDoneReading()) {
@@ -3085,7 +3088,7 @@
 
 bool QuicFramer::ProcessIetfFrameData(QuicDataReader* reader,
                                       const QuicPacketHeader& header) {
-  DCHECK(VersionHasIetfQuicFrames(version_.transport_version))
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version))
       << "Attempt to process frames as IETF frames but version ("
       << version_.transport_version << ") does not support IETF Framing.";
 
@@ -3458,7 +3461,7 @@
 
 // Set |num_bits|, offset by |offset| to |val| in |flags|.
 void SetBits(uint8_t* flags, uint8_t val, uint8_t num_bits, uint8_t offset) {
-  DCHECK_LE(val, GetMaskFromNumBits(num_bits));
+  QUICHE_DCHECK_LE(val, GetMaskFromNumBits(num_bits));
   *flags |= val << offset;
 }
 
@@ -3576,7 +3579,7 @@
     return false;
   }
   frame->data_buffer = data.data();
-  DCHECK_EQ(frame->data_length, data.length());
+  QUICHE_DCHECK_EQ(frame->data_length, data.length());
 
   return true;
 }
@@ -4144,7 +4147,7 @@
 
 bool QuicFramer::ProcessBlockedFrame(QuicDataReader* reader,
                                      QuicBlockedFrame* frame) {
-  DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
+  QUICHE_DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
       << "Attempt to process non-IETF QUIC frames in an IETF QUIC version.";
 
   if (!reader->ReadUInt32(&frame->stream_id)) {
@@ -4162,7 +4165,7 @@
   uint8_t next_byte;
   while (!reader->IsDoneReading() && reader->PeekByte() == 0x00) {
     reader->ReadBytes(&next_byte, 1);
-    DCHECK_EQ(0x00, next_byte);
+    QUICHE_DCHECK_EQ(0x00, next_byte);
     ++frame->num_padding_bytes;
   }
 }
@@ -4219,9 +4222,9 @@
 
 void QuicFramer::SetDecrypter(EncryptionLevel level,
                               std::unique_ptr<QuicDecrypter> decrypter) {
-  DCHECK_EQ(alternative_decrypter_level_, NUM_ENCRYPTION_LEVELS);
-  DCHECK_GE(level, decrypter_level_);
-  DCHECK(!version_.KnowsWhichDecrypterToUse());
+  QUICHE_DCHECK_EQ(alternative_decrypter_level_, NUM_ENCRYPTION_LEVELS);
+  QUICHE_DCHECK_GE(level, decrypter_level_);
+  QUICHE_DCHECK(!version_.KnowsWhichDecrypterToUse());
   QUIC_DVLOG(1) << ENDPOINT << "Setting decrypter from level "
                 << decrypter_level_ << " to " << level;
   decrypter_[decrypter_level_] = nullptr;
@@ -4233,8 +4236,8 @@
     EncryptionLevel level,
     std::unique_ptr<QuicDecrypter> decrypter,
     bool latch_once_used) {
-  DCHECK_NE(level, decrypter_level_);
-  DCHECK(!version_.KnowsWhichDecrypterToUse());
+  QUICHE_DCHECK_NE(level, decrypter_level_);
+  QUICHE_DCHECK(!version_.KnowsWhichDecrypterToUse());
   QUIC_DVLOG(1) << ENDPOINT << "Setting alternative decrypter from level "
                 << alternative_decrypter_level_ << " to " << level;
   if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
@@ -4247,13 +4250,13 @@
 
 void QuicFramer::InstallDecrypter(EncryptionLevel level,
                                   std::unique_ptr<QuicDecrypter> decrypter) {
-  DCHECK(version_.KnowsWhichDecrypterToUse());
+  QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
   QUIC_DVLOG(1) << ENDPOINT << "Installing decrypter at level " << level;
   decrypter_[level] = std::move(decrypter);
 }
 
 void QuicFramer::RemoveDecrypter(EncryptionLevel level) {
-  DCHECK(version_.KnowsWhichDecrypterToUse());
+  QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
   QUIC_DVLOG(1) << ENDPOINT << "Removing decrypter at level " << level;
   decrypter_[level] = nullptr;
 }
@@ -4264,13 +4267,13 @@
 }
 
 void QuicFramer::DiscardPreviousOneRttKeys() {
-  DCHECK(support_key_update_for_connection_);
+  QUICHE_DCHECK(support_key_update_for_connection_);
   QUIC_DVLOG(1) << ENDPOINT << "Discarding previous set of 1-RTT keys";
   previous_decrypter_ = nullptr;
 }
 
 bool QuicFramer::DoKeyUpdate(KeyUpdateReason reason) {
-  DCHECK(support_key_update_for_connection_);
+  QUICHE_DCHECK(support_key_update_for_connection_);
   if (!next_decrypter_) {
     // If key update is locally initiated, next decrypter might not be created
     // yet.
@@ -4298,7 +4301,7 @@
 }
 
 const QuicDecrypter* QuicFramer::GetDecrypter(EncryptionLevel level) const {
-  DCHECK(version_.KnowsWhichDecrypterToUse());
+  QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
   return decrypter_[level].get();
 }
 
@@ -4315,8 +4318,8 @@
 
 void QuicFramer::SetEncrypter(EncryptionLevel level,
                               std::unique_ptr<QuicEncrypter> encrypter) {
-  DCHECK_GE(level, 0);
-  DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
+  QUICHE_DCHECK_GE(level, 0);
+  QUICHE_DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
   QUIC_DVLOG(1) << ENDPOINT << "Setting encrypter at level " << level;
   encrypter_[level] = std::move(encrypter);
 }
@@ -4340,7 +4343,7 @@
                                   size_t total_len,
                                   size_t buffer_len,
                                   char* buffer) {
-  DCHECK(packet_number.IsInitialized());
+  QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
     QUIC_BUG << ENDPOINT
              << "Attempted to encrypt in place without encrypter at level "
@@ -4595,7 +4598,7 @@
                                   const QuicPacket& packet,
                                   char* buffer,
                                   size_t buffer_len) {
-  DCHECK(packet_number.IsInitialized());
+  QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
     QUIC_BUG << ENDPOINT << "Attempted to encrypt without encrypter at level "
              << level;
@@ -4711,8 +4714,8 @@
     }
     if (support_key_update_for_connection_ &&
         header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
-      DCHECK(version().UsesTls());
-      DCHECK_EQ(level, ENCRYPTION_FORWARD_SECURE);
+      QUICHE_DCHECK(version().UsesTls());
+      QUICHE_DCHECK_EQ(level, ENCRYPTION_FORWARD_SECURE);
       key_phase = (header.type_byte & FLAGS_KEY_PHASE_BIT) != 0;
       key_phase_parsed = true;
       QUIC_DVLOG(1) << ENDPOINT << "packet " << header.packet_number
@@ -4791,7 +4794,7 @@
         set_detailed_error("Key update failed due to internal error");
         return RaiseError(QUIC_INTERNAL_ERROR);
       }
-      DCHECK_EQ(current_key_phase_bit_, key_phase);
+      QUICHE_DCHECK_EQ(current_key_phase_bit_, key_phase);
     }
     if (key_phase_parsed &&
         !current_key_phase_first_received_packet_number_.IsInitialized() &&
@@ -4809,7 +4812,7 @@
     }
   } else if (alternative_decrypter != nullptr) {
     if (header.nonce != nullptr) {
-      DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+      QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
       alternative_decrypter->SetDiversificationNonce(*header.nonce);
     }
     bool try_alternative_decryption = true;
@@ -4820,7 +4823,7 @@
           try_alternative_decryption = false;
         }
       } else {
-        DCHECK(header.nonce == nullptr);
+        QUICHE_DCHECK(header.nonce == nullptr);
       }
     }
 
@@ -4909,7 +4912,7 @@
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicPacketNumberLength /*packet_number_length*/) {
-  DCHECK(!ack.packets.Empty());
+  QUICHE_DCHECK(!ack.packets.Empty());
   size_t ack_size = 0;
 
   if (VersionHasIetfQuicFrames(version_.transport_version)) {
@@ -4975,7 +4978,7 @@
                                  last_frame_in_packet,
                                  frame.message_frame->message_length);
     case PADDING_FRAME:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       return 0;
     default:
       return GetRetransmittableControlFrameSize(version_.transport_version,
@@ -5165,7 +5168,7 @@
 bool QuicFramer::AppendPacketNumber(QuicPacketNumberLength packet_number_length,
                                     QuicPacketNumber packet_number,
                                     QuicDataWriter* writer) {
-  DCHECK(packet_number.IsInitialized());
+  QUICHE_DCHECK(packet_number.IsInitialized());
   if (!IsValidPacketNumberLength(packet_number_length)) {
     QUIC_BUG << "Invalid packet_number_length: " << packet_number_length;
     return false;
@@ -5243,7 +5246,7 @@
   }
 
   if (data_producer_ != nullptr) {
-    DCHECK_EQ(nullptr, frame.data_buffer);
+    QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
     if (frame.data_length == 0) {
       return true;
     }
@@ -5332,7 +5335,7 @@
       return false;
     }
   } else {
-    DCHECK_EQ(nullptr, frame.data_buffer);
+    QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
 
     if (data_producer_->WriteStreamData(frame.stream_id, frame.offset,
                                         frame.data_length,
@@ -5361,7 +5364,7 @@
       return false;
     }
   } else {
-    DCHECK_EQ(nullptr, frame.data_buffer);
+    QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
     if (!data_producer_->WriteCryptoData(frame.level, frame.offset,
                                          frame.data_length, writer)) {
       return false;
@@ -5394,7 +5397,8 @@
 }
 
 void QuicFramer::set_version(const ParsedQuicVersion version) {
-  DCHECK(IsSupportedVersion(version)) << ParsedQuicVersionToString(version);
+  QUICHE_DCHECK(IsSupportedVersion(version))
+      << ParsedQuicVersionToString(version);
   version_ = version;
 }
 
@@ -5416,7 +5420,7 @@
       GetMinAckFrameSize(version_.transport_version, frame,
                          local_ack_delay_exponent_) -
       (new_ack_info.num_ack_blocks != 0 ? kNumberOfAckBlocksSize : 0);
-  DCHECK_LE(0, available_timestamp_and_ack_block_bytes);
+  QUICHE_DCHECK_LE(0, available_timestamp_and_ack_block_bytes);
 
   uint8_t type_byte = 0;
   SetBit(&type_byte, new_ack_info.num_ack_blocks != 0,
@@ -5452,7 +5456,7 @@
   // Largest acked delta time.
   uint64_t ack_delay_time_us = kUFloat16MaxValue;
   if (!frame.ack_delay_time.IsInfinite()) {
-    DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
+    QUICHE_DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
     ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
   }
   if (!writer->WriteUFloat16(ack_delay_time_us)) {
@@ -5524,7 +5528,7 @@
       }
       ++num_ack_blocks_written;
     }
-    DCHECK_EQ(num_ack_blocks, num_ack_blocks_written);
+    QUICHE_DCHECK_EQ(num_ack_blocks, num_ack_blocks_written);
   }
   // Timestamps.
   // If we don't process timestamps or if we don't have enough available space
@@ -5546,8 +5550,8 @@
 
 bool QuicFramer::AppendTimestampsToAckFrame(const QuicAckFrame& frame,
                                             QuicDataWriter* writer) {
-  DCHECK_GE(std::numeric_limits<uint8_t>::max(),
-            frame.received_packet_times.size());
+  QUICHE_DCHECK_GE(std::numeric_limits<uint8_t>::max(),
+                   frame.received_packet_times.size());
   // num_received_packets is only 1 byte.
   if (frame.received_packet_times.size() >
       std::numeric_limits<uint8_t>::max()) {
@@ -5566,7 +5570,8 @@
   QuicPacketNumber packet_number = it->first;
   uint64_t delta_from_largest_observed = LargestAcked(frame) - packet_number;
 
-  DCHECK_GE(std::numeric_limits<uint8_t>::max(), delta_from_largest_observed);
+  QUICHE_DCHECK_GE(std::numeric_limits<uint8_t>::max(),
+                   delta_from_largest_observed);
   if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
     return false;
   }
@@ -5610,9 +5615,9 @@
 bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
                                         const QuicStopWaitingFrame& frame,
                                         QuicDataWriter* writer) {
-  DCHECK(!version_.HasIetfInvariantHeader());
-  DCHECK(frame.least_unacked.IsInitialized());
-  DCHECK_GE(header.packet_number, frame.least_unacked);
+  QUICHE_DCHECK(!version_.HasIetfInvariantHeader());
+  QUICHE_DCHECK(frame.least_unacked.IsInitialized());
+  QUICHE_DCHECK_GE(header.packet_number, frame.least_unacked);
   const uint64_t least_unacked_delta =
       header.packet_number - frame.least_unacked;
   const uint64_t length_shift = header.packet_number_length * 8;
@@ -5664,7 +5669,7 @@
 
   uint64_t ack_delay_time_us = kVarInt62MaxValue;
   if (!frame.ack_delay_time.IsInfinite()) {
-    DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
+    QUICHE_DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
     ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
     ack_delay_time_us = ack_delay_time_us >> local_ack_delay_exponent_;
   }
@@ -5710,7 +5715,7 @@
     }
     const bool success =
         writer->WriteVarInt62(gap) && writer->WriteVarInt62(ack_range);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
     previous_smallest = iter->min();
     ++appended_ack_blocks;
   }
@@ -6365,7 +6370,7 @@
 uint8_t QuicFramer::GetIetfStreamFrameTypeByte(
     const QuicStreamFrame& frame,
     bool last_frame_in_packet) const {
-  DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
   uint8_t type_byte = IETF_STREAM;
   if (!last_frame_in_packet) {
     type_byte |= IETF_STREAM_FRAME_LEN_BIT;
@@ -6382,8 +6387,8 @@
 void QuicFramer::InferPacketHeaderTypeFromVersion() {
   // This function should only be called when server connection negotiates the
   // version.
-  DCHECK_EQ(perspective_, Perspective::IS_SERVER);
-  DCHECK(!infer_packet_header_type_from_version_);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_SERVER);
+  QUICHE_DCHECK(!infer_packet_header_type_from_version_);
   infer_packet_header_type_from_version_ = true;
 }
 
@@ -6620,7 +6625,7 @@
     return QUIC_NO_ERROR;
   }
 
-  DCHECK_EQ(IETF_QUIC_LONG_HEADER_PACKET, *format);
+  QUICHE_DCHECK_EQ(IETF_QUIC_LONG_HEADER_PACKET, *format);
   *version_present = true;
   if (!ProcessVersionLabel(reader, version_label)) {
     *detailed_error = "Unable to read protocol version.";
@@ -6751,7 +6756,7 @@
   }
   // Fill the rest of the packet with zeroes.
   writer.WritePadding();
-  DCHECK_EQ(0u, writer.remaining());
+  QUICHE_DCHECK_EQ(0u, writer.remaining());
   return true;
 }
 
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 4859ad6..12b779a 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -364,7 +364,7 @@
   }
 
   bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override {
-    DCHECK(!ack_frames_.empty());
+    QUICHE_DCHECK(!ack_frames_.empty());
     ack_frames_[ack_frames_.size() - 1]->packets.AddRange(start, end);
     if (VersionHasIetfQuicFrames(transport_version_)) {
       EXPECT_TRUE(IETF_ACK == framer_->current_received_frame_type() ||
@@ -433,7 +433,7 @@
     ++frame_count_;
     handshake_done_frames_.push_back(
         std::make_unique<QuicHandshakeDoneFrame>(frame));
-    DCHECK(VersionHasIetfQuicFrames(transport_version_));
+    QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version_));
     EXPECT_EQ(IETF_HANDSHAKE_DONE, framer_->current_received_frame_type());
     return true;
   }
@@ -442,7 +442,7 @@
     ++frame_count_;
     ack_frequency_frames_.emplace_back(
         std::make_unique<QuicAckFrequencyFrame>(frame));
-    DCHECK(VersionHasIetfQuicFrames(transport_version_));
+    QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version_));
     EXPECT_EQ(IETF_ACK_FREQUENCY, framer_->current_received_frame_type());
     return true;
   }
@@ -2762,7 +2762,7 @@
   // If IETF frames are in use then we must also have the IETF
   // header invariants.
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
-    DCHECK(framer_.version().HasIetfInvariantHeader());
+    QUICHE_DCHECK(framer_.version().HasIetfInvariantHeader());
   }
 
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
diff --git a/quic/core/quic_idle_network_detector.cc b/quic/core/quic_idle_network_detector.cc
index e310f69..8046e44 100644
--- a/quic/core/quic_idle_network_detector.cc
+++ b/quic/core/quic_idle_network_detector.cc
@@ -112,7 +112,7 @@
 
 void QuicIdleNetworkDetector::MaybeSetAlarmOnSentPacket(
     QuicTime::Delta pto_delay) {
-  DCHECK(shorter_idle_timeout_on_sent_packet_);
+  QUICHE_DCHECK(shorter_idle_timeout_on_sent_packet_);
   if (!handshake_timeout_.IsInfinite() || !alarm_->IsSet()) {
     SetAlarm();
     return;
diff --git a/quic/core/quic_legacy_version_encapsulator.cc b/quic/core/quic_legacy_version_encapsulator.cc
index b9fd693..bfe2df2 100644
--- a/quic/core/quic_legacy_version_encapsulator.cc
+++ b/quic/core/quic_legacy_version_encapsulator.cc
@@ -99,8 +99,8 @@
   outer_chlo.SetStringPiece(kSNI, sni);
   outer_chlo.SetStringPiece(kQLVE, inner_packet);
   const QuicData& serialized_outer_chlo = outer_chlo.GetSerialized();
-  DCHECK(!LegacyVersionForEncapsulation().UsesCryptoFrames());
-  DCHECK(LegacyVersionForEncapsulation().UsesQuicCrypto());
+  QUICHE_DCHECK(!LegacyVersionForEncapsulation().UsesCryptoFrames());
+  QUICHE_DCHECK(LegacyVersionForEncapsulation().UsesQuicCrypto());
   QuicStreamFrame outer_stream_frame(
       QuicUtils::GetCryptoStreamId(
           LegacyVersionForEncapsulation().transport_version),
diff --git a/quic/core/quic_linux_socket_utils.cc b/quic/core/quic_linux_socket_utils.cc
index ecb691e..c2931af 100644
--- a/quic/core/quic_linux_socket_utils.cc
+++ b/quic/core/quic_linux_socket_utils.cc
@@ -25,7 +25,7 @@
       cbuf_size_(cbuf_size),
       cmsg_(nullptr) {
   // Only support unconnected sockets.
-  DCHECK(peer_address.IsInitialized());
+  QUICHE_DCHECK(peer_address.IsInitialized());
 
   raw_peer_address_ = peer_address.generic_address();
   hdr_.msg_name = &raw_peer_address_;
@@ -61,19 +61,19 @@
   // msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
   // return nullptr.
   hdr_.msg_controllen += CMSG_SPACE(data_size);
-  DCHECK_LE(hdr_.msg_controllen, cbuf_size_);
+  QUICHE_DCHECK_LE(hdr_.msg_controllen, cbuf_size_);
 
   if (cmsg_ == nullptr) {
-    DCHECK_EQ(nullptr, hdr_.msg_control);
+    QUICHE_DCHECK_EQ(nullptr, hdr_.msg_control);
     memset(cbuf_, 0, cbuf_size_);
     hdr_.msg_control = cbuf_;
     cmsg_ = CMSG_FIRSTHDR(&hdr_);
   } else {
-    DCHECK_NE(nullptr, hdr_.msg_control);
+    QUICHE_DCHECK_NE(nullptr, hdr_.msg_control);
     cmsg_ = CMSG_NXTHDR(&hdr_, cmsg_);
   }
 
-  DCHECK_NE(nullptr, cmsg_) << "Insufficient control buffer space";
+  QUICHE_DCHECK_NE(nullptr, cmsg_) << "Insufficient control buffer space";
 
   cmsg_->cmsg_len = CMSG_LEN(data_size);
   cmsg_->cmsg_level = cmsg_level;
@@ -95,7 +95,7 @@
   hdr->msg_controllen = 0;
 
   // Only support unconnected sockets.
-  DCHECK(buffered_write.peer_address.IsInitialized());
+  QUICHE_DCHECK(buffered_write.peer_address.IsInitialized());
 
   sockaddr_storage* peer_address_storage = GetPeerAddressStorage(i);
   *peer_address_storage = buffered_write.peer_address.generic_address();
@@ -131,18 +131,18 @@
   // msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
   // return nullptr.
   hdr->msg_controllen += CMSG_SPACE(data_size);
-  DCHECK_LE(hdr->msg_controllen, cbuf_size_);
+  QUICHE_DCHECK_LE(hdr->msg_controllen, cbuf_size_);
 
   if (cmsg == nullptr) {
-    DCHECK_EQ(nullptr, hdr->msg_control);
+    QUICHE_DCHECK_EQ(nullptr, hdr->msg_control);
     hdr->msg_control = GetCbuf(i);
     cmsg = CMSG_FIRSTHDR(hdr);
   } else {
-    DCHECK_NE(nullptr, hdr->msg_control);
+    QUICHE_DCHECK_NE(nullptr, hdr->msg_control);
     cmsg = CMSG_NXTHDR(hdr, cmsg);
   }
 
-  DCHECK_NE(nullptr, cmsg) << "Insufficient control buffer space";
+  QUICHE_DCHECK_NE(nullptr, cmsg) << "Insufficient control buffer space";
 
   cmsg->cmsg_len = CMSG_LEN(data_size);
   cmsg->cmsg_level = cmsg_level;
@@ -152,8 +152,8 @@
 }
 
 int QuicMMsgHdr::num_bytes_sent(int num_packets_sent) {
-  DCHECK_LE(0, num_packets_sent);
-  DCHECK_LE(num_packets_sent, num_msgs_);
+  QUICHE_DCHECK_LE(0, num_packets_sent);
+  QUICHE_DCHECK_LE(num_packets_sent, num_msgs_);
 
   int bytes_sent = 0;
   iovec* iov = GetIov(0);
@@ -219,7 +219,7 @@
 void QuicLinuxSocketUtils::SetIpInfoInCmsgData(
     const QuicIpAddress& self_address,
     void* cmsg_data) {
-  DCHECK(self_address.IsInitialized());
+  QUICHE_DCHECK(self_address.IsInitialized());
   const std::string& address_str = self_address.ToPackedString();
   if (self_address.IsIPv4()) {
     in_pktinfo* pktinfo = static_cast<in_pktinfo*>(cmsg_data);
diff --git a/quic/core/quic_mtu_discovery.cc b/quic/core/quic_mtu_discovery.cc
index 400efda..056a4bd 100644
--- a/quic/core/quic_mtu_discovery.cc
+++ b/quic/core/quic_mtu_discovery.cc
@@ -17,7 +17,7 @@
 void QuicConnectionMtuDiscoverer::Enable(
     QuicByteCount max_packet_length,
     QuicByteCount target_max_packet_length) {
-  DCHECK(!IsEnabled());
+  QUICHE_DCHECK(!IsEnabled());
 
   if (target_max_packet_length <= max_packet_length) {
     QUIC_DVLOG(1) << "MtuDiscoverer not enabled. target_max_packet_length:"
@@ -28,7 +28,7 @@
 
   min_probe_length_ = max_packet_length;
   max_probe_length_ = target_max_packet_length;
-  DCHECK(IsEnabled());
+  QUICHE_DCHECK(IsEnabled());
 
   QUIC_DVLOG(1) << "MtuDiscoverer enabled. min:" << min_probe_length_
                 << ", max:" << max_probe_length_
@@ -70,7 +70,7 @@
 
 QuicPacketLength QuicConnectionMtuDiscoverer::GetUpdatedMtuProbeSize(
     QuicPacketNumber largest_sent_packet) {
-  DCHECK(ShouldProbeMtu(largest_sent_packet));
+  QUICHE_DCHECK(ShouldProbeMtu(largest_sent_packet));
 
   QuicPacketLength probe_packet_length = next_probe_packet_length();
   if (probe_packet_length == last_probe_length_) {
@@ -78,7 +78,7 @@
     // previous one exceeded MTU, we need to decrease the probe packet length.
     max_probe_length_ = probe_packet_length;
   } else {
-    DCHECK_GT(probe_packet_length, last_probe_length_);
+    QUICHE_DCHECK_GT(probe_packet_length, last_probe_length_);
   }
   last_probe_length_ = next_probe_packet_length();
 
@@ -93,14 +93,14 @@
                 << ", New packets_between_probes_:" << packets_between_probes_
                 << ", next_probe_at_:" << next_probe_at_
                 << ", remaining_probe_count_:" << remaining_probe_count_;
-  DCHECK(!ShouldProbeMtu(largest_sent_packet));
+  QUICHE_DCHECK(!ShouldProbeMtu(largest_sent_packet));
   return last_probe_length_;
 }
 
 QuicPacketLength QuicConnectionMtuDiscoverer::next_probe_packet_length() const {
-  DCHECK_NE(min_probe_length_, 0);
-  DCHECK_NE(max_probe_length_, 0);
-  DCHECK_GE(max_probe_length_, min_probe_length_);
+  QUICHE_DCHECK_NE(min_probe_length_, 0);
+  QUICHE_DCHECK_NE(max_probe_length_, 0);
+  QUICHE_DCHECK_GE(max_probe_length_, min_probe_length_);
 
   const QuicPacketLength normal_next_probe_length =
       (min_probe_length_ + max_probe_length_ + 1) / 2;
@@ -121,7 +121,7 @@
     return;
   }
 
-  DCHECK_EQ(old_value, min_probe_length_);
+  QUICHE_DCHECK_EQ(old_value, min_probe_length_);
   min_probe_length_ = new_value;
 }
 
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 7dbe37a..9dabd3a 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -159,7 +159,7 @@
 }
 
 void QuicPacketCreator::SetMaxPacketLength(QuicByteCount length) {
-  DCHECK(CanSetMaxPacketLength());
+  QUICHE_DCHECK(CanSetMaxPacketLength());
 
   // Avoid recomputing |max_plaintext_size_| if the length does not actually
   // change.
@@ -192,7 +192,7 @@
 }
 
 void QuicPacketCreator::SetSoftMaxPacketLength(QuicByteCount length) {
-  DCHECK(CanSetMaxPacketLength());
+  QUICHE_DCHECK(CanSetMaxPacketLength());
   if (length > max_packet_length_) {
     QUIC_BUG << ENDPOINT
              << "Try to increase max_packet_length_ in "
@@ -217,18 +217,18 @@
 // A packet that is already open might send kQuicVersionSize bytes less than the
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
-  DCHECK(send_version_in_packet_);
-  DCHECK(!version().HasIetfInvariantHeader());
+  QUICHE_DCHECK(send_version_in_packet_);
+  QUICHE_DCHECK(!version().HasIetfInvariantHeader());
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
-    DCHECK_LT(kQuicVersionSize, packet_size_);
+    QUICHE_DCHECK_LT(kQuicVersionSize, packet_size_);
     packet_size_ -= kQuicVersionSize;
   }
 }
 
 void QuicPacketCreator::SetDiversificationNonce(
     const DiversificationNonce& nonce) {
-  DCHECK(!have_diversification_nonce_);
+  QUICHE_DCHECK(!have_diversification_nonce_);
   have_diversification_nonce_ = true;
   diversification_nonce_ = nonce;
 }
@@ -246,7 +246,7 @@
   }
 
   const QuicPacketNumber next_packet_number = NextSendingPacketNumber();
-  DCHECK_LE(least_packet_awaited_by_peer, next_packet_number);
+  QUICHE_DCHECK_LE(least_packet_awaited_by_peer, next_packet_number);
   const uint64_t current_delta =
       next_packet_number - least_packet_awaited_by_peer;
   const uint64_t delta = std::max(current_delta, max_packets_in_flight);
@@ -414,14 +414,14 @@
                                           QuicFrame* frame) {
   // Make sure max_packet_length_ is greater than the largest possible overhead
   // or max_packet_length_ is set to the soft limit.
-  DCHECK(max_packet_length_ >
-             StreamFramePacketOverhead(
-                 framer_->transport_version(),
-                 GetDestinationConnectionIdLength(),
-                 GetSourceConnectionIdLength(), kIncludeVersion,
-                 IncludeNonceInPublicHeader(), PACKET_6BYTE_PACKET_NUMBER,
-                 GetRetryTokenLengthLength(), GetLengthLength(), offset) ||
-         latched_hard_max_packet_length_ > 0);
+  QUICHE_DCHECK(
+      max_packet_length_ >
+          StreamFramePacketOverhead(
+              framer_->transport_version(), GetDestinationConnectionIdLength(),
+              GetSourceConnectionIdLength(), kIncludeVersion,
+              IncludeNonceInPublicHeader(), PACKET_6BYTE_PACKET_NUMBER,
+              GetRetryTokenLengthLength(), GetLengthLength(), offset) ||
+      latched_hard_max_packet_length_ > 0);
 
   QUIC_BUG_IF(!HasRoomForStreamFrame(id, offset, data_size))
       << "No room for Stream frame, BytesFree: " << BytesFree()
@@ -471,7 +471,7 @@
     external_buffer.release_buffer = nullptr;
   }
 
-  DCHECK_EQ(nullptr, packet_.encrypted_buffer);
+  QUICHE_DCHECK_EQ(nullptr, packet_.encrypted_buffer);
   if (!SerializePacket(std::move(external_buffer), kMaxOutgoingPacketSize)) {
     return;
   }
@@ -500,8 +500,8 @@
   QUIC_BUG_IF(packet_.release_encrypted_buffer != nullptr)
       << "packet_.release_encrypted_buffer should be empty";
   packet_.release_encrypted_buffer = nullptr;
-  DCHECK(packet_.retransmittable_frames.empty());
-  DCHECK(packet_.nonretransmittable_frames.empty());
+  QUICHE_DCHECK(packet_.retransmittable_frames.empty());
+  QUICHE_DCHECK(packet_.nonretransmittable_frames.empty());
   packet_.largest_acked.Clear();
   needs_full_padding_ = false;
 }
@@ -564,8 +564,8 @@
     TransmissionType transmission_type,
     size_t* num_bytes_consumed) {
   // TODO(b/167222597): consider using ScopedSerializationFailureHandler.
-  DCHECK(queued_frames_.empty());
-  DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
+  QUICHE_DCHECK(queued_frames_.empty());
+  QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
   // Write out the packet header
   QuicPacketHeader header;
   FillPacketHeader(&header);
@@ -651,8 +651,8 @@
 
   packet_.transmission_type = transmission_type;
 
-  DCHECK(packet_.encryption_level == ENCRYPTION_FORWARD_SECURE ||
-         packet_.encryption_level == ENCRYPTION_ZERO_RTT)
+  QUICHE_DCHECK(packet_.encryption_level == ENCRYPTION_FORWARD_SECURE ||
+                packet_.encryption_level == ENCRYPTION_ZERO_RTT)
       << packet_.encryption_level;
   size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
@@ -721,7 +721,7 @@
 }
 
 size_t QuicPacketCreator::BytesFree() const {
-  DCHECK_GE(max_plaintext_size_, PacketSize());
+  QUICHE_DCHECK_GE(max_plaintext_size_, PacketSize());
   return max_plaintext_size_ -
          std::min(max_plaintext_size_, PacketSize() + ExpansionOnNewFrame());
 }
@@ -752,7 +752,7 @@
   }
   ScopedSerializationFailureHandler handler(this);
 
-  DCHECK_LT(0u, encrypted_buffer_len);
+  QUICHE_DCHECK_LT(0u, encrypted_buffer_len);
   QUIC_BUG_IF(queued_frames_.empty() && pending_padding_bytes_ == 0)
       << "Attempt to serialize empty packet";
   QuicPacketHeader header;
@@ -785,7 +785,7 @@
     return false;
   }
 
-  DCHECK_GE(max_plaintext_size_, packet_size_);
+  QUICHE_DCHECK_GE(max_plaintext_size_, packet_size_);
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
   size_t length =
@@ -813,7 +813,7 @@
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated_by_length) {
-    DCHECK_EQ(packet_size_, length);
+    QUICHE_DCHECK_EQ(packet_size_, length);
   }
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
@@ -848,14 +848,14 @@
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   size_t length = BuildConnectivityProbingPacket(
       header, buffer.get(), max_plaintext_size_, packet_.encryption_level);
-  DCHECK(length);
+  QUICHE_DCHECK(length);
 
-  DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+  QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
       kMaxOutgoingPacketSize, buffer.get());
-  DCHECK(encrypted_length);
+  QUICHE_DCHECK(encrypted_length);
 
   std::unique_ptr<SerializedPacket> serialize_packet(new SerializedPacket(
       header.packet_number, header.packet_number_length, buffer.release(),
@@ -888,14 +888,14 @@
   size_t length =
       BuildPaddedPathChallengePacket(header, buffer.get(), max_plaintext_size_,
                                      payload, packet_.encryption_level);
-  DCHECK(length);
+  QUICHE_DCHECK(length);
 
-  DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+  QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
       kMaxOutgoingPacketSize, buffer.get());
-  DCHECK(encrypted_length);
+  QUICHE_DCHECK(encrypted_length);
 
   std::unique_ptr<SerializedPacket> serialize_packet(
       new SerializedPacket(header.packet_number, header.packet_number_length,
@@ -930,14 +930,14 @@
   size_t length =
       BuildPathResponsePacket(header, buffer.get(), max_plaintext_size_,
                               payloads, is_padded, packet_.encryption_level);
-  DCHECK(length);
+  QUICHE_DCHECK(length);
 
-  DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+  QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
       kMaxOutgoingPacketSize, buffer.get());
-  DCHECK(encrypted_length);
+  QUICHE_DCHECK(encrypted_length);
 
   std::unique_ptr<SerializedPacket> serialize_packet(
       new SerializedPacket(header.packet_number, header.packet_number_length,
@@ -959,7 +959,7 @@
     size_t packet_length,
     const QuicPathFrameBuffer& payload,
     EncryptionLevel level) {
-  DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
   QuicFrames frames;
 
   // Write a PATH_CHALLENGE frame, which has a random 8-byte payload
@@ -990,7 +990,7 @@
         << "Attempt to generate connectivity response with no request payloads";
     return 0;
   }
-  DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
 
   std::vector<std::unique_ptr<QuicPathResponseFrame>> path_response_frames;
   for (const QuicPathFrameBuffer& payload : payloads) {
@@ -1129,8 +1129,8 @@
 
 QuicConnectionIdLength QuicPacketCreator::GetDestinationConnectionIdLength()
     const {
-  DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
-                                                  transport_version()));
+  QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
+                                                         transport_version()));
   return GetDestinationConnectionIdIncluded() == CONNECTION_ID_PRESENT
              ? static_cast<QuicConnectionIdLength>(
                    GetDestinationConnectionId().length())
@@ -1138,8 +1138,8 @@
 }
 
 QuicConnectionIdLength QuicPacketCreator::GetSourceConnectionIdLength() const {
-  DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
-                                                  transport_version()));
+  QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
+                                                         transport_version()));
   return GetSourceConnectionIdIncluded() == CONNECTION_ID_PRESENT
              ? static_cast<QuicConnectionIdLength>(
                    GetSourceConnectionId().length())
@@ -1190,7 +1190,7 @@
   QUIC_BUG_IF(IsControlFrame(frame.type) && !GetControlFrameId(frame) &&
               frame.type != PING_FRAME)
       << "Adding a control frame with no control frame id: " << frame;
-  DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
+  QUICHE_DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
   MaybeBundleAckOpportunistically();
   if (HasPendingFrames()) {
     if (AddFrame(frame, next_transmission_type_)) {
@@ -1198,7 +1198,7 @@
       return true;
     }
   }
-  DCHECK(!HasPendingFrames());
+  QUICHE_DCHECK(!HasPendingFrames());
   if (frame.type != PING_FRAME && frame.type != CONNECTION_CLOSE_FRAME &&
       !delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
                                        NOT_HANDSHAKE)) {
@@ -1270,8 +1270,8 @@
     if (fin_consumed && state == FIN_AND_PADDING) {
       AddRandomPadding();
     }
-    DCHECK(total_bytes_consumed == write_length ||
-           (bytes_consumed > 0 && HasPendingFrames()));
+    QUICHE_DCHECK(total_bytes_consumed == write_length ||
+                  (bytes_consumed > 0 && HasPendingFrames()));
 
     if (total_bytes_consumed == write_length) {
       // We're done writing the data. Exit the loop.
@@ -1306,7 +1306,7 @@
     QuicStreamOffset offset,
     bool fin,
     size_t total_bytes_consumed) {
-  DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
+  QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
   if (AttemptingToSendUnencryptedStreamData()) {
     return QuicConsumedData(total_bytes_consumed,
                             fin && (total_bytes_consumed == write_length));
@@ -1429,14 +1429,14 @@
               !frames.empty() && has_ack())
       << "Trying to flush " << frames << " when there is ACK queued";
   for (const auto& frame : frames) {
-    DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME);
+    QUICHE_DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME);
     if (HasPendingFrames()) {
       if (AddFrame(frame, next_transmission_type_)) {
         // There is pending frames and current frame fits.
         continue;
       }
     }
-    DCHECK(!HasPendingFrames());
+    QUICHE_DCHECK(!HasPendingFrames());
     // There is no pending frames, consult the delegate whether a packet can be
     // generated.
     if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
@@ -1541,7 +1541,7 @@
   header->reset_flag = false;
   header->version_flag = IncludeVersionInHeader();
   if (IncludeNonceInPublicHeader()) {
-    DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
+    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
     header->nonce = &diversification_nonce_;
   } else {
     header->nonce = nullptr;
@@ -1615,9 +1615,9 @@
 
   // If this is an ACK frame, validate that it is non-empty and that
   // largest_acked matches the max packet number.
-  DCHECK(frame.type != ACK_FRAME ||
-         (!frame.ack_frame->packets.Empty() &&
-          frame.ack_frame->packets.Max() == frame.ack_frame->largest_acked))
+  QUICHE_DCHECK(frame.type != ACK_FRAME || (!frame.ack_frame->packets.Empty() &&
+                                            frame.ack_frame->packets.Max() ==
+                                                frame.ack_frame->largest_acked))
       << "Invalid ACK frame: " << frame;
 
   size_t frame_len = GetSerializedFrameLength(frame);
@@ -1634,7 +1634,7 @@
   if (queued_frames_.empty()) {
     packet_size_ = PacketHeaderSize();
   }
-  DCHECK_LT(0u, packet_size_);
+  QUICHE_DCHECK_LT(0u, packet_size_);
 
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
@@ -1711,12 +1711,12 @@
 
   // The back of retransmittable frames must be the same as the original
   // queued frames' back.
-  DCHECK_EQ(packet_.retransmittable_frames.back().type, STREAM_FRAME);
+  QUICHE_DCHECK_EQ(packet_.retransmittable_frames.back().type, STREAM_FRAME);
   QuicStreamFrame* retransmittable =
       &packet_.retransmittable_frames.back().stream_frame;
-  DCHECK_EQ(retransmittable->stream_id, frame.stream_id);
-  DCHECK_EQ(retransmittable->offset + retransmittable->data_length,
-            frame.offset);
+  QUICHE_DCHECK_EQ(retransmittable->stream_id, frame.stream_id);
+  QUICHE_DCHECK_EQ(retransmittable->offset + retransmittable->data_length,
+                   frame.offset);
   retransmittable->data_length = candidate->data_length;
   retransmittable->fin = candidate->fin;
   packet_size_ += frame.data_length;
@@ -1808,10 +1808,10 @@
 
 void QuicPacketCreator::SetServerConnectionIdIncluded(
     QuicConnectionIdIncluded server_connection_id_included) {
-  DCHECK(server_connection_id_included == CONNECTION_ID_PRESENT ||
-         server_connection_id_included == CONNECTION_ID_ABSENT);
-  DCHECK(framer_->perspective() == Perspective::IS_SERVER ||
-         server_connection_id_included != CONNECTION_ID_ABSENT);
+  QUICHE_DCHECK(server_connection_id_included == CONNECTION_ID_PRESENT ||
+                server_connection_id_included == CONNECTION_ID_ABSENT);
+  QUICHE_DCHECK(framer_->perspective() == Perspective::IS_SERVER ||
+                server_connection_id_included != CONNECTION_ID_ABSENT);
   server_connection_id_included_ = server_connection_id_included;
 }
 
@@ -1822,8 +1822,8 @@
 
 void QuicPacketCreator::SetClientConnectionId(
     QuicConnectionId client_connection_id) {
-  DCHECK(client_connection_id.IsEmpty() ||
-         framer_->version().SupportsClientConnectionIds());
+  QUICHE_DCHECK(client_connection_id.IsEmpty() ||
+                framer_->version().SupportsClientConnectionIds());
   client_connection_id_ = client_connection_id;
 }
 
@@ -1889,7 +1889,7 @@
   const QuicPacketLength largest_payload =
       largest_frame - std::min(largest_frame, kQuicFrameTypeSize);
   // This must always be less than or equal to GetCurrentLargestMessagePayload.
-  DCHECK_LE(largest_payload, GetCurrentLargestMessagePayload());
+  QUICHE_DCHECK_LE(largest_payload, GetCurrentLargestMessagePayload());
   return largest_payload;
 }
 
@@ -2001,7 +2001,7 @@
 }
 
 void QuicPacketCreator::set_encryption_level(EncryptionLevel level) {
-  DCHECK(level == packet_.encryption_level || !HasPendingFrames())
+  QUICHE_DCHECK(level == packet_.encryption_level || !HasPendingFrames())
       << "Cannot update encryption level from " << packet_.encryption_level
       << " to " << level << " when we already have pending frames: "
       << QuicFramesToString(queued_frames_);
@@ -2048,7 +2048,7 @@
     }
   }
   // Frame was not queued but queued frames were flushed.
-  DCHECK(!HasPendingFrames());
+  QUICHE_DCHECK(!HasPendingFrames());
   if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
                                        NOT_HANDSHAKE)) {
     return false;
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index da0c6b2..8ff44c1 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -2442,7 +2442,7 @@
   ~QuicPacketCreatorMultiplePacketsTest() override {}
 
   void SavePacket(SerializedPacket packet) {
-    DCHECK(packet.release_encrypted_buffer == nullptr);
+    QUICHE_DCHECK(packet.release_encrypted_buffer == nullptr);
     packet.encrypted_buffer = CopyBuffer(packet);
     packet.release_encrypted_buffer = [](const char* p) { delete[] p; };
     packets_.push_back(std::move(packet));
diff --git a/quic/core/quic_packet_number.cc b/quic/core/quic_packet_number.cc
index d326434..ba1c509 100644
--- a/quic/core/quic_packet_number.cc
+++ b/quic/core/quic_packet_number.cc
@@ -25,12 +25,12 @@
 }
 
 uint64_t QuicPacketNumber::Hash() const {
-  DCHECK(IsInitialized());
+  QUICHE_DCHECK(IsInitialized());
   return packet_number_;
 }
 
 uint64_t QuicPacketNumber::ToUint64() const {
-  DCHECK(IsInitialized());
+  QUICHE_DCHECK(IsInitialized());
   return packet_number_;
 }
 
@@ -40,8 +40,8 @@
 
 QuicPacketNumber& QuicPacketNumber::operator++() {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_LT(ToUint64(), std::numeric_limits<uint64_t>::max() - 1);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_LT(ToUint64(), std::numeric_limits<uint64_t>::max() - 1);
 #endif
   packet_number_++;
   return *this;
@@ -49,8 +49,8 @@
 
 QuicPacketNumber QuicPacketNumber::operator++(int) {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_LT(ToUint64(), std::numeric_limits<uint64_t>::max() - 1);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_LT(ToUint64(), std::numeric_limits<uint64_t>::max() - 1);
 #endif
   QuicPacketNumber previous(*this);
   packet_number_++;
@@ -59,8 +59,8 @@
 
 QuicPacketNumber& QuicPacketNumber::operator--() {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_GE(ToUint64(), 1UL);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_GE(ToUint64(), 1UL);
 #endif
   packet_number_--;
   return *this;
@@ -68,8 +68,8 @@
 
 QuicPacketNumber QuicPacketNumber::operator--(int) {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_GE(ToUint64(), 1UL);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_GE(ToUint64(), 1UL);
 #endif
   QuicPacketNumber previous(*this);
   packet_number_--;
@@ -78,8 +78,8 @@
 
 QuicPacketNumber& QuicPacketNumber::operator+=(uint64_t delta) {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_GT(std::numeric_limits<uint64_t>::max() - ToUint64(), delta);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_GT(std::numeric_limits<uint64_t>::max() - ToUint64(), delta);
 #endif
   packet_number_ += delta;
   return *this;
@@ -87,8 +87,8 @@
 
 QuicPacketNumber& QuicPacketNumber::operator-=(uint64_t delta) {
 #ifndef NDEBUG
-  DCHECK(IsInitialized());
-  DCHECK_GE(ToUint64(), delta);
+  QUICHE_DCHECK(IsInitialized());
+  QUICHE_DCHECK_GE(ToUint64(), delta);
 #endif
   packet_number_ -= delta;
   return *this;
diff --git a/quic/core/quic_packet_reader.cc b/quic/core/quic_packet_reader.cc
index 7b03762..4b0eb4b 100644
--- a/quic/core/quic_packet_reader.cc
+++ b/quic/core/quic_packet_reader.cc
@@ -20,7 +20,7 @@
 QuicPacketReader::QuicPacketReader()
     : read_buffers_(kNumPacketsPerReadMmsgCall),
       read_results_(kNumPacketsPerReadMmsgCall) {
-  DCHECK_EQ(read_buffers_.size(), read_results_.size());
+  QUICHE_DCHECK_EQ(read_buffers_.size(), read_results_.size());
   for (size_t i = 0; i < read_results_.size(); ++i) {
     read_results_[i].packet_buffer.buffer = read_buffers_[i].packet_buffer;
     read_results_[i].packet_buffer.buffer_len =
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 51946aa..5f3e5a2 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -74,8 +74,8 @@
 QuicConnectionIdLength GetIncludedConnectionIdLength(
     QuicConnectionId connection_id,
     QuicConnectionIdIncluded connection_id_included) {
-  DCHECK(connection_id_included == CONNECTION_ID_PRESENT ||
-         connection_id_included == CONNECTION_ID_ABSENT);
+  QUICHE_DCHECK(connection_id_included == CONNECTION_ID_PRESENT ||
+                connection_id_included == CONNECTION_ID_ABSENT);
   return connection_id_included == CONNECTION_ID_PRESENT
              ? static_cast<QuicConnectionIdLength>(connection_id.length())
              : PACKET_0BYTE_CONNECTION_ID;
@@ -127,9 +127,9 @@
       if (VersionHasLengthPrefixedConnectionIds(version)) {
         size += kConnectionIdLengthSize;
       }
-      DCHECK(QuicVersionHasLongHeaderLengths(version) ||
-             retry_token_length_length + retry_token_length + length_length ==
-                 0);
+      QUICHE_DCHECK(
+          QuicVersionHasLongHeaderLengths(version) ||
+          retry_token_length_length + retry_token_length + length_length == 0);
       if (QuicVersionHasLongHeaderLengths(version)) {
         size += retry_token_length_length + retry_token_length + length_length;
       }
@@ -140,8 +140,8 @@
            packet_number_length;
   }
   // Google QUIC versions <= 43 can only carry one connection ID.
-  DCHECK(destination_connection_id_length == 0 ||
-         source_connection_id_length == 0);
+  QUICHE_DCHECK(destination_connection_id_length == 0 ||
+                source_connection_id_length == 0);
   return kPublicFlagsSize + destination_connection_id_length +
          source_connection_id_length +
          (include_version ? kQuicVersionSize : 0) + packet_number_length +
@@ -534,7 +534,7 @@
   // Copy underlying frames.
   copy->retransmittable_frames =
       CopyQuicFrames(allocator, serialized.retransmittable_frames);
-  DCHECK(copy->nonretransmittable_frames.empty());
+  QUICHE_DCHECK(copy->nonretransmittable_frames.empty());
   for (const auto& frame : serialized.nonretransmittable_frames) {
     if (frame.type == ACK_FRAME) {
       copy->has_ack_frame_copy = true;
diff --git a/quic/core/quic_path_validator.cc b/quic/core/quic_path_validator.cc
index 0cc387f..ac4f3ed 100644
--- a/quic/core/quic_path_validator.cc
+++ b/quic/core/quic_path_validator.cc
@@ -68,7 +68,7 @@
 void QuicPathValidator::StartPathValidation(
     std::unique_ptr<QuicPathValidationContext> context,
     std::unique_ptr<ResultDelegate> result_delegate) {
-  DCHECK(context);
+  QUICHE_DCHECK(context);
   QUIC_DLOG(INFO) << "Start validating path " << *context
                   << " via writer: " << context->WriterToUse();
   if (path_context_ != nullptr) {
diff --git a/quic/core/quic_received_packet_manager.cc b/quic/core/quic_received_packet_manager.cc
index 4546399..2b43442 100644
--- a/quic/core/quic_received_packet_manager.cc
+++ b/quic/core/quic_received_packet_manager.cc
@@ -72,7 +72,8 @@
     const QuicPacketHeader& header,
     QuicTime receipt_time) {
   const QuicPacketNumber packet_number = header.packet_number;
-  DCHECK(IsAwaitingPacket(packet_number)) << " packet_number:" << packet_number;
+  QUICHE_DCHECK(IsAwaitingPacket(packet_number))
+      << " packet_number:" << packet_number;
   was_last_packet_missing_ = IsMissing(packet_number);
   if (!ack_frame_updated_) {
     ack_frame_.received_packet_times.clear();
@@ -174,8 +175,8 @@
     return;
   }
   // ValidateAck() should fail if peer_least_packet_awaiting_ack shrinks.
-  DCHECK(!peer_least_packet_awaiting_ack_.IsInitialized() ||
-         peer_least_packet_awaiting_ack_ <= least_unacked);
+  QUICHE_DCHECK(!peer_least_packet_awaiting_ack_.IsInitialized() ||
+                peer_least_packet_awaiting_ack_ <= least_unacked);
   if (!peer_least_packet_awaiting_ack_.IsInitialized() ||
       least_unacked > peer_least_packet_awaiting_ack_) {
     peer_least_packet_awaiting_ack_ = least_unacked;
@@ -186,9 +187,9 @@
       ack_frame_updated_ = true;
     }
   }
-  DCHECK(ack_frame_.packets.Empty() ||
-         !peer_least_packet_awaiting_ack_.IsInitialized() ||
-         ack_frame_.packets.Min() >= peer_least_packet_awaiting_ack_);
+  QUICHE_DCHECK(ack_frame_.packets.Empty() ||
+                !peer_least_packet_awaiting_ack_.IsInitialized() ||
+                ack_frame_.packets.Min() >= peer_least_packet_awaiting_ack_);
 }
 
 QuicTime::Delta QuicReceivedPacketManager::GetMaxAckDelay(
diff --git a/quic/core/quic_received_packet_manager_test.cc b/quic/core/quic_received_packet_manager_test.cc
index 4935b2a..3cfa0ce 100644
--- a/quic/core/quic_received_packet_manager_test.cc
+++ b/quic/core/quic_received_packet_manager_test.cc
@@ -72,12 +72,12 @@
   }
 
   void CheckAckTimeout(QuicTime time) {
-    DCHECK(HasPendingAck());
-    DCHECK_EQ(received_manager_.ack_timeout(), time);
+    QUICHE_DCHECK(HasPendingAck());
+    QUICHE_DCHECK_EQ(received_manager_.ack_timeout(), time);
     if (time <= clock_.ApproximateNow()) {
       // ACK timeout expires, send an ACK.
       received_manager_.ResetAckStates();
-      DCHECK(!HasPendingAck());
+      QUICHE_DCHECK(!HasPendingAck());
     }
   }
 
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 4f2b200..61d680c 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -594,7 +594,7 @@
 
 bool QuicSentPacketManager::ShouldAddMaxAckDelay(
     PacketNumberSpace space) const {
-  DCHECK(pto_enabled_);
+  QUICHE_DCHECK(pto_enabled_);
   if (supports_multiple_packet_number_spaces() && space != APPLICATION_DATA) {
     // When the PTO is armed for Initial or Handshake packet number spaces,
     // the max_ack_delay is 0.
@@ -631,7 +631,7 @@
 
 QuicTime QuicSentPacketManager::GetEarliestPacketSentTimeForPto(
     PacketNumberSpace* packet_number_space) const {
-  DCHECK(supports_multiple_packet_number_spaces());
+  QUICHE_DCHECK(supports_multiple_packet_number_spaces());
   QuicTime earliest_sent_time = QuicTime::Zero();
   for (int8_t i = 0; i < NUM_PACKET_NUMBER_SPACES; ++i) {
     const QuicTime sent_time = unacked_packets_.GetLastInFlightPacketSentTime(
@@ -665,8 +665,8 @@
       << " transmission_type: " << transmission_type << " transmission_info "
       << transmission_info->DebugString();
   // Handshake packets should never be sent as probing retransmissions.
-  DCHECK(!transmission_info->has_crypto_handshake ||
-         transmission_type != PROBING_RETRANSMISSION);
+  QUICHE_DCHECK(!transmission_info->has_crypto_handshake ||
+                transmission_type != PROBING_RETRANSMISSION);
 
   HandleRetransmission(transmission_type, transmission_info);
 
@@ -826,8 +826,8 @@
     bool measure_rtt) {
   const SerializedPacket& packet = *mutable_packet;
   QuicPacketNumber packet_number = packet.packet_number;
-  DCHECK_LE(FirstSendingPacketNumber(), packet_number);
-  DCHECK(!unacked_packets_.IsUnacked(packet_number));
+  QUICHE_DCHECK_LE(FirstSendingPacketNumber(), packet_number);
+  QUICHE_DCHECK(!unacked_packets_.IsUnacked(packet_number));
   QUIC_BUG_IF(packet.encrypted_length == 0) << "Cannot send empty packets.";
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
@@ -876,9 +876,9 @@
 
 QuicSentPacketManager::RetransmissionTimeoutMode
 QuicSentPacketManager::OnRetransmissionTimeout() {
-  DCHECK(unacked_packets_.HasInFlightPackets() ||
-         (handshake_mode_disabled_ && !handshake_finished_));
-  DCHECK_EQ(0u, pending_timer_transmission_count_);
+  QUICHE_DCHECK(unacked_packets_.HasInFlightPackets() ||
+                (handshake_mode_disabled_ && !handshake_finished_));
+  QUICHE_DCHECK_EQ(0u, pending_timer_transmission_count_);
   // Handshake retransmission, timer based loss detection, TLP, and RTO are
   // implemented with a single alarm. The handshake alarm is set when the
   // handshake has not completed, the loss alarm is set when the loss detection
@@ -886,7 +886,7 @@
   // The TLP alarm is always set to run for under an RTO.
   switch (GetRetransmissionMode()) {
     case HANDSHAKE_MODE:
-      DCHECK(!handshake_mode_disabled_);
+      QUICHE_DCHECK(!handshake_mode_disabled_);
       ++stats_->crypto_retransmit_count;
       RetransmitCryptoPackets();
       return HANDSHAKE_MODE;
@@ -924,7 +924,7 @@
 }
 
 void QuicSentPacketManager::RetransmitCryptoPackets() {
-  DCHECK_EQ(HANDSHAKE_MODE, GetRetransmissionMode());
+  QUICHE_DCHECK_EQ(HANDSHAKE_MODE, GetRetransmissionMode());
   ++consecutive_crypto_retransmission_count_;
   bool packet_retransmitted = false;
   std::vector<QuicPacketNumber> crypto_retransmissions;
@@ -965,14 +965,15 @@
       ++pending_timer_transmission_count_;
     }
   }
-  DCHECK(packet_retransmitted) << "No crypto packets found to retransmit.";
+  QUICHE_DCHECK(packet_retransmitted)
+      << "No crypto packets found to retransmit.";
   for (QuicPacketNumber retransmission : crypto_retransmissions) {
     MarkForRetransmission(retransmission, HANDSHAKE_RETRANSMISSION);
   }
 }
 
 bool QuicSentPacketManager::MaybeRetransmitTailLossProbe() {
-  DCHECK(!pto_enabled_);
+  QUICHE_DCHECK(!pto_enabled_);
   if (pending_timer_transmission_count_ == 0) {
     return false;
   }
@@ -1022,7 +1023,7 @@
 }
 
 void QuicSentPacketManager::RetransmitRtoPackets() {
-  DCHECK(!pto_enabled_);
+  QUICHE_DCHECK(!pto_enabled_);
   QUIC_BUG_IF(pending_timer_transmission_count_ > 0)
       << "Retransmissions already queued:" << pending_timer_transmission_count_;
   // Mark two packets for retransmission.
@@ -1038,7 +1039,7 @@
         if (transmission_info->state == OUTSTANDING &&
             unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
             pending_timer_transmission_count_ < max_rto_packets_) {
-          DCHECK(transmission_info->in_flight);
+          QUICHE_DCHECK(transmission_info->in_flight);
           retransmissions.push_back(packet_number);
           ++pending_timer_transmission_count_;
         }
@@ -1051,7 +1052,7 @@
       if (it->state == OUTSTANDING &&
           unacked_packets_.HasRetransmittableFrames(*it) &&
           pending_timer_transmission_count_ < max_rto_packets_) {
-        DCHECK(it->in_flight);
+        QUICHE_DCHECK(it->in_flight);
         retransmissions.push_back(packet_number);
         ++pending_timer_transmission_count_;
       }
@@ -1104,7 +1105,7 @@
             (!supports_multiple_packet_number_spaces() ||
              unacked_packets_.GetPacketNumberSpace(
                  transmission_info->encryption_level) == packet_number_space)) {
-          DCHECK(transmission_info->in_flight);
+          QUICHE_DCHECK(transmission_info->in_flight);
           probing_packets.push_back(packet_number);
           if (probing_packets.size() == pending_timer_transmission_count_) {
             break;
@@ -1121,7 +1122,7 @@
           (!supports_multiple_packet_number_spaces() ||
            unacked_packets_.GetPacketNumberSpace(it->encryption_level) ==
                packet_number_space)) {
-        DCHECK(it->in_flight);
+        QUICHE_DCHECK(it->in_flight);
         probing_packets.push_back(packet_number);
         if (probing_packets.size() == pending_timer_transmission_count_) {
           break;
@@ -1173,7 +1174,7 @@
 
 void QuicSentPacketManager::RetransmitDataOfSpaceIfAny(
     PacketNumberSpace space) {
-  DCHECK(supports_multiple_packet_number_spaces());
+  QUICHE_DCHECK(supports_multiple_packet_number_spaces());
   if (!unacked_packets_.GetLastInFlightPacketSentTime(space).IsInitialized()) {
     // No in flight data of space.
     return;
@@ -1192,7 +1193,7 @@
           unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
           unacked_packets_.GetPacketNumberSpace(
               transmission_info->encryption_level) == space) {
-        DCHECK(transmission_info->in_flight);
+        QUICHE_DCHECK(transmission_info->in_flight);
         if (pending_timer_transmission_count_ == 0) {
           pending_timer_transmission_count_ = 1;
         }
@@ -1208,7 +1209,7 @@
           unacked_packets_.HasRetransmittableFrames(*it) &&
           unacked_packets_.GetPacketNumberSpace(it->encryption_level) ==
               space) {
-        DCHECK(it->in_flight);
+        QUICHE_DCHECK(it->in_flight);
         if (pending_timer_transmission_count_ == 0) {
           pending_timer_transmission_count_ = 1;
         }
@@ -1221,8 +1222,8 @@
 
 QuicSentPacketManager::RetransmissionTimeoutMode
 QuicSentPacketManager::GetRetransmissionMode() const {
-  DCHECK(unacked_packets_.HasInFlightPackets() ||
-         (handshake_mode_disabled_ && !handshake_finished_));
+  QUICHE_DCHECK(unacked_packets_.HasInFlightPackets() ||
+                (handshake_mode_disabled_ && !handshake_finished_));
   if (!handshake_mode_disabled_ && !handshake_finished_ &&
       unacked_packets_.HasPendingCryptoPackets()) {
     return HANDSHAKE_MODE;
@@ -1243,8 +1244,8 @@
 
 void QuicSentPacketManager::InvokeLossDetection(QuicTime time) {
   if (!packets_acked_.empty()) {
-    DCHECK_LE(packets_acked_.front().packet_number,
-              packets_acked_.back().packet_number);
+    QUICHE_DCHECK_LE(packets_acked_.front().packet_number,
+                     packets_acked_.back().packet_number);
     largest_newly_acked_ = packets_acked_.back().packet_number;
   }
   LossDetectionInterface::DetectionStats detection_stats =
@@ -1357,7 +1358,7 @@
     case LOSS_MODE:
       return loss_algorithm_->GetLossTimeout();
     case TLP_MODE: {
-      DCHECK(!pto_enabled_);
+      QUICHE_DCHECK(!pto_enabled_);
       // TODO(ianswett): When CWND is available, it would be preferable to
       // set the timer based on the earliest retransmittable packet.
       // Base the updated timer on the send time of the last packet.
@@ -1368,7 +1369,7 @@
       return std::max(clock_->ApproximateNow(), tlp_time);
     }
     case RTO_MODE: {
-      DCHECK(!pto_enabled_);
+      QUICHE_DCHECK(!pto_enabled_);
       // The RTO is based on the first outstanding packet.
       const QuicTime sent_time =
           unacked_packets_.GetLastInFlightPacketSentTime();
@@ -1433,7 +1434,7 @@
           earliest_right_edge + GetProbeTimeoutDelay(packet_number_space));
     }
   }
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return QuicTime::Zero();
 }
 
@@ -1519,7 +1520,7 @@
 
 const QuicTime::Delta QuicSentPacketManager::GetProbeTimeoutDelay(
     PacketNumberSpace space) const {
-  DCHECK(pto_enabled_);
+  QUICHE_DCHECK(pto_enabled_);
   if (rtt_stats_.smoothed_rtt().IsZero()) {
     // Respect kMinHandshakeTimeoutMs to avoid a potential amplification attack.
     QUIC_BUG_IF(rtt_stats_.initial_rtt().IsZero());
@@ -1614,7 +1615,7 @@
       // them as useless, thus not contributing to RTT stats.
       if (unacked_packets_.HasRetransmittableFrames(packet_number)) {
         MarkForRetransmission(packet_number, PATH_RETRANSMISSION);
-        DCHECK_EQ(it->state, NOT_CONTRIBUTING_RTT);
+        QUICHE_DCHECK_EQ(it->state, NOT_CONTRIBUTING_RTT);
       }
     }
     it->state = NOT_CONTRIBUTING_RTT;
@@ -1625,8 +1626,8 @@
 void QuicSentPacketManager::OnAckFrameStart(QuicPacketNumber largest_acked,
                                             QuicTime::Delta ack_delay_time,
                                             QuicTime ack_receive_time) {
-  DCHECK(packets_acked_.empty());
-  DCHECK_LE(largest_acked, unacked_packets_.largest_sent_packet());
+  QUICHE_DCHECK(packets_acked_.empty());
+  QUICHE_DCHECK_LE(largest_acked, unacked_packets_.largest_sent_packet());
   if (ack_delay_time > peer_max_ack_delay()) {
     ack_delay_time = peer_max_ack_delay();
   }
@@ -1799,7 +1800,7 @@
 
 QuicPacketNumber QuicSentPacketManager::GetLargestAckedPacket(
     EncryptionLevel decrypted_packet_level) const {
-  DCHECK(supports_multiple_packet_number_spaces());
+  QUICHE_DCHECK(supports_multiple_packet_number_spaces());
   return unacked_packets_.GetLargestAckedOfPacketNumberSpace(
       QuicUtils::GetPacketNumberSpace(decrypted_packet_level));
 }
@@ -1827,7 +1828,7 @@
 
 QuicPacketNumber QuicSentPacketManager::GetLargestPacketPeerKnowsIsAcked(
     EncryptionLevel decrypted_packet_level) const {
-  DCHECK(supports_multiple_packet_number_spaces());
+  QUICHE_DCHECK(supports_multiple_packet_number_spaces());
   return largest_packets_peer_knows_is_acked_[QuicUtils::GetPacketNumberSpace(
       decrypted_packet_level)];
 }
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 5c308f0..5112cde 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -155,14 +155,14 @@
     return;
   }
 
-  DCHECK_EQ(QuicUtils::GetCryptoStreamId(transport_version()),
-            GetMutableCryptoStream()->id());
+  QUICHE_DCHECK_EQ(QuicUtils::GetCryptoStreamId(transport_version()),
+                   GetMutableCryptoStream()->id());
 }
 
 QuicSession::~QuicSession() {}
 
 void QuicSession::PendingStreamOnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
@@ -181,7 +181,7 @@
   }
   if (ProcessPendingStream(pending)) {
     // The pending stream should now be in the scope of normal streams.
-    DCHECK(IsClosedStream(stream_id) || IsOpenStream(stream_id))
+    QUICHE_DCHECK(IsClosedStream(stream_id) || IsOpenStream(stream_id))
         << "Stream " << stream_id << " not created";
     pending_stream_map_.erase(stream_id);
     return;
@@ -230,13 +230,13 @@
 
 void QuicSession::OnStopSendingFrame(const QuicStopSendingFrame& frame) {
   // STOP_SENDING is in IETF QUIC only.
-  DCHECK(VersionHasIetfQuicFrames(transport_version()));
-  DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
 
   QuicStreamId stream_id = frame.stream_id;
   // If Stream ID is invalid then close the connection.
   // TODO(ianswett): This check is redundant to checks for IsClosedStream,
-  // but removing it requires removing multiple DCHECKs.
+  // but removing it requires removing multiple QUICHE_DCHECKs.
   // TODO(ianswett): Multiple QUIC_DVLOGs could be QUIC_PEER_BUGs.
   if (stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
     QUIC_DVLOG(1) << ENDPOINT
@@ -300,7 +300,7 @@
 }
 
 void QuicSession::PendingStreamOnRstStream(const QuicRstStreamFrame& frame) {
-  DCHECK(VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
@@ -312,9 +312,10 @@
 
   pending->OnRstStreamFrame(frame);
   // Pending stream is currently read only. We can safely close the stream.
-  DCHECK_EQ(READ_UNIDIRECTIONAL,
-            QuicUtils::GetStreamType(pending->id(), perspective(),
-                                     /*peer_initiated = */ true, version()));
+  QUICHE_DCHECK_EQ(
+      READ_UNIDIRECTIONAL,
+      QuicUtils::GetStreamType(pending->id(), perspective(),
+                               /*peer_initiated = */ true, version()));
   ClosePendingStream(stream_id);
 }
 
@@ -377,7 +378,7 @@
 }
 
 void QuicSession::OnNewTokenReceived(absl::string_view token) {
-  DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   GetMutableCryptoStream()->OnNewTokenReceived(token);
 }
 
@@ -399,7 +400,7 @@
 
 void QuicSession::OnConnectionClosed(const QuicConnectionCloseFrame& frame,
                                      ConnectionCloseSource source) {
-  DCHECK(!connection_->connected());
+  QUICHE_DCHECK(!connection_->connected());
   if (perspective() == Perspective::IS_SERVER) {
     RecordConnectionCloseAtServer(frame.quic_error_code, source);
   }
@@ -637,9 +638,9 @@
                     << " bytes_written " << previous_bytes_written << " fin "
                     << previous_fin_sent;
       stream->OnCanWrite();
-      DCHECK(CheckStreamWriteBlocked(stream));
-      DCHECK(CheckStreamNotBusyLooping(stream, previous_bytes_written,
-                                       previous_fin_sent));
+      QUICHE_DCHECK(CheckStreamWriteBlocked(stream));
+      QUICHE_DCHECK(CheckStreamNotBusyLooping(stream, previous_bytes_written,
+                                              previous_fin_sent));
     }
     currently_writing_stream_id_ = 0;
   }
@@ -739,15 +740,16 @@
     StreamSendingState state,
     TransmissionType type,
     absl::optional<EncryptionLevel> level) {
-  DCHECK(connection_->connected())
+  QUICHE_DCHECK(connection_->connected())
       << ENDPOINT << "Try to write stream data when connection is closed.";
-  DCHECK(!use_write_or_buffer_data_at_level_ || level.has_value());
+  QUICHE_DCHECK(!use_write_or_buffer_data_at_level_ || level.has_value());
   if (!IsEncryptionEstablished() &&
       !QuicUtils::IsCryptoStreamId(transport_version(), id)) {
     // Do not let streams write without encryption. The calling stream will end
     // up write blocked until OnCanWrite is next called.
     if (was_zero_rtt_rejected_ && !OneRttKeysAvailable()) {
-      DCHECK(version().UsesTls() && perspective() == Perspective::IS_CLIENT);
+      QUICHE_DCHECK(version().UsesTls() &&
+                    perspective() == Perspective::IS_CLIENT);
       QUIC_BUG_IF(type == NOT_RETRANSMISSION)
           << ENDPOINT << "Try to send new data on stream " << id
           << "before 1-RTT keys are available while 0-RTT is rejected.";
@@ -791,7 +793,7 @@
                                    size_t write_length,
                                    QuicStreamOffset offset,
                                    TransmissionType type) {
-  DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
+  QUICHE_DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
   if (!connection()->framer().HasEncrypterOfEncryptionLevel(level)) {
     const std::string error_details = absl::StrCat(
         "Try to send crypto data with missing keys of encryption level: ",
@@ -827,7 +829,7 @@
 
 bool QuicSession::WriteControlFrame(const QuicFrame& frame,
                                     TransmissionType type) {
-  DCHECK(connection()->connected())
+  QUICHE_DCHECK(connection()->connected())
       << ENDPOINT << "Try to write control frames when connection is closed.";
   if (connection_->encrypted_control_frames()) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_encrypted_control_frames);
@@ -849,7 +851,7 @@
                                 QuicRstStreamErrorCode error,
                                 QuicStreamOffset bytes_written,
                                 bool send_rst_only) {
-  DCHECK(!split_up_send_rst());
+  QUICHE_DCHECK(!split_up_send_rst());
   if (!connection()->connected()) {
     return;
   }
@@ -897,7 +899,7 @@
 void QuicSession::MaybeSendRstStreamFrame(QuicStreamId id,
                                           QuicRstStreamErrorCode error,
                                           QuicStreamOffset bytes_written) {
-  DCHECK(split_up_send_rst());
+  QUICHE_DCHECK(split_up_send_rst());
   if (!connection()->connected()) {
     return;
   }
@@ -912,7 +914,7 @@
 
 void QuicSession::MaybeSendStopSendingFrame(QuicStreamId id,
                                             QuicRstStreamErrorCode error) {
-  DCHECK(split_up_send_rst());
+  QUICHE_DCHECK(split_up_send_rst());
   if (!connection()->connected()) {
     return;
   }
@@ -926,7 +928,7 @@
 void QuicSession::SendGoAway(QuicErrorCode error_code,
                              const std::string& reason) {
   // GOAWAY frame is not supported in IETF QUIC.
-  DCHECK(!VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(!VersionHasIetfQuicFrames(transport_version()));
   if (GetQuicReloadableFlag(quic_encrypted_goaway)) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_encrypted_goaway, 1, 2);
     if (!IsEncryptionEstablished()) {
@@ -942,7 +944,7 @@
   }
   transport_goaway_sent_ = true;
   if (GetQuicReloadableFlag(quic_goaway_with_max_stream_id)) {
-    DCHECK_EQ(perspective(), Perspective::IS_SERVER);
+    QUICHE_DCHECK_EQ(perspective(), Perspective::IS_SERVER);
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_goaway_with_max_stream_id, 2, 2);
     control_frame_manager_.WriteOrBufferGoAway(
         error_code,
@@ -1026,7 +1028,7 @@
     // received, for accurate connection level flow control accounting.
     // If this is an outgoing stream, it is technically open from peer's
     // perspective. Do not inform stream Id manager yet.
-    DCHECK(!stream->was_draining());
+    QUICHE_DCHECK(!stream->was_draining());
     InsertLocallyClosedStreamsHighestOffset(
         stream_id, stream->highest_received_byte_offset());
     return;
@@ -1066,7 +1068,7 @@
 
 void QuicSession::ClosePendingStream(QuicStreamId stream_id) {
   QUIC_DVLOG(1) << ENDPOINT << "Closing stream " << stream_id;
-  DCHECK(VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version()));
   pending_stream_map_.erase(stream_id);
   if (connection_->connected()) {
     ietf_streamid_manager_.OnStreamClosed(stream_id);
@@ -1367,7 +1369,7 @@
 
 void QuicSession::HandleFrameOnNonexistentOutgoingStream(
     QuicStreamId stream_id) {
-  DCHECK(!IsClosedStream(stream_id));
+  QUICHE_DCHECK(!IsClosedStream(stream_id));
   // Received a frame for a locally-created stream that is not currently
   // active. This is an error.
   if (VersionHasIetfQuicFrames(transport_version())) {
@@ -1394,7 +1396,7 @@
 }
 
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
-  DCHECK(version().UsesQuicCrypto());
+  QUICHE_DCHECK(version().UsesQuicCrypto());
   QUIC_DVLOG(1) << ENDPOINT << "OnNewStreamFlowControlWindow " << new_window;
   if (new_window < kMinimumFlowControlSendWindow) {
     QUIC_LOG_FIRST_N(ERROR, 1)
@@ -1427,7 +1429,7 @@
 
 void QuicSession::OnNewStreamUnidirectionalFlowControlWindow(
     QuicStreamOffset new_window) {
-  DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
+  QUICHE_DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
   QUIC_DVLOG(1) << ENDPOINT << "OnNewStreamUnidirectionalFlowControlWindow "
                 << new_window;
   // Inform all existing outgoing unidirectional streams about the new window.
@@ -1457,7 +1459,7 @@
 
 void QuicSession::OnNewStreamOutgoingBidirectionalFlowControlWindow(
     QuicStreamOffset new_window) {
-  DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
+  QUICHE_DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
   QUIC_DVLOG(1) << ENDPOINT
                 << "OnNewStreamOutgoingBidirectionalFlowControlWindow "
                 << new_window;
@@ -1488,7 +1490,7 @@
 
 void QuicSession::OnNewStreamIncomingBidirectionalFlowControlWindow(
     QuicStreamOffset new_window) {
-  DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
+  QUICHE_DCHECK_EQ(connection_->version().handshake_protocol, PROTOCOL_TLS1_3);
   QUIC_DVLOG(1) << ENDPOINT
                 << "OnNewStreamIncomingBidirectionalFlowControlWindow "
                 << new_window;
@@ -1619,7 +1621,8 @@
 }
 
 void QuicSession::SetDefaultEncryptionLevel(EncryptionLevel level) {
-  DCHECK_EQ(PROTOCOL_QUIC_CRYPTO, connection_->version().handshake_protocol);
+  QUICHE_DCHECK_EQ(PROTOCOL_QUIC_CRYPTO,
+                   connection_->version().handshake_protocol);
   QUIC_DVLOG(1) << ENDPOINT << "Set default encryption level to " << level;
   connection()->SetDefaultEncryptionLevel(level);
 
@@ -1649,7 +1652,7 @@
 }
 
 void QuicSession::OnTlsHandshakeComplete() {
-  DCHECK_EQ(PROTOCOL_TLS1_3, connection_->version().handshake_protocol);
+  QUICHE_DCHECK_EQ(PROTOCOL_TLS1_3, connection_->version().handshake_protocol);
   QUIC_BUG_IF(!GetCryptoStream()->crypto_negotiated_params().cipher_suite)
       << ENDPOINT << "Handshake completes without cipher suite negotiation.";
   QUIC_BUG_IF(!config_.negotiated())
@@ -1671,8 +1674,8 @@
 }
 
 void QuicSession::MaybeSendAddressToken() {
-  DCHECK(perspective_ == Perspective::IS_SERVER &&
-         connection()->version().HasIetfQuicFrames());
+  QUICHE_DCHECK(perspective_ == Perspective::IS_SERVER &&
+                connection()->version().HasIetfQuicFrames());
   std::string address_token = GetCryptoStream()->GetAddressToken();
   if (address_token.empty()) {
     return;
@@ -1799,7 +1802,7 @@
   bool is_static = stream->is_static();
   QUIC_DVLOG(1) << ENDPOINT << "num_streams: " << stream_map_.size()
                 << ". activating stream " << stream_id;
-  DCHECK(!QuicContainsKey(stream_map_, stream_id));
+  QUICHE_DCHECK(!QuicContainsKey(stream_map_, stream_id));
   stream_map_[stream_id] = std::move(stream);
   if (is_static) {
     ++num_static_streams_;
@@ -1828,7 +1831,7 @@
 
 bool QuicSession::CanOpenNextOutgoingBidirectionalStream() {
   if (liveness_testing_in_progress_) {
-    DCHECK_EQ(Perspective::IS_CLIENT, perspective());
+    QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective());
     return false;
   }
   if (!VersionHasIetfQuicFrames(transport_version())) {
@@ -1874,12 +1877,12 @@
 
 QuicStreamCount QuicSession::GetAdvertisedMaxIncomingBidirectionalStreams()
     const {
-  DCHECK(VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version()));
   return ietf_streamid_manager_.advertised_max_incoming_bidirectional_streams();
 }
 
 QuicStream* QuicSession::GetOrCreateStream(const QuicStreamId stream_id) {
-  DCHECK(!QuicContainsKey(pending_stream_map_, stream_id));
+  QUICHE_DCHECK(!QuicContainsKey(pending_stream_map_, stream_id));
   if (QuicUtils::IsCryptoStreamId(transport_version(), stream_id)) {
     return GetMutableCryptoStream();
   }
@@ -1918,7 +1921,7 @@
 }
 
 void QuicSession::StreamDraining(QuicStreamId stream_id, bool unidirectional) {
-  DCHECK(QuicContainsKey(stream_map_, stream_id));
+  QUICHE_DCHECK(QuicContainsKey(stream_map_, stream_id));
   QUIC_DVLOG(1) << ENDPOINT << "Stream " << stream_id << " is draining";
   if (VersionHasIetfQuicFrames(transport_version())) {
     ietf_streamid_manager_.OnStreamClosed(stream_id);
@@ -1983,7 +1986,7 @@
 
 void QuicSession::set_largest_peer_created_stream_id(
     QuicStreamId largest_peer_created_stream_id) {
-  DCHECK(!VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(!VersionHasIetfQuicFrames(transport_version()));
   stream_id_manager_.set_largest_peer_created_stream_id(
       largest_peer_created_stream_id);
 }
@@ -1991,7 +1994,7 @@
 QuicStreamId QuicSession::GetLargestPeerCreatedStreamId(
     bool unidirectional) const {
   // This method is only used in IETF QUIC.
-  DCHECK(VersionHasIetfQuicFrames(transport_version()));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version()));
   return ietf_streamid_manager_.GetLargestPeerCreatedStreamId(unidirectional);
 }
 
@@ -2015,7 +2018,7 @@
 }
 
 bool QuicSession::IsClosedStream(QuicStreamId id) {
-  DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
+  QUICHE_DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
   if (IsOpenStream(id)) {
     // Stream is active
     return false;
@@ -2029,7 +2032,7 @@
 }
 
 bool QuicSession::IsOpenStream(QuicStreamId id) {
-  DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
+  QUICHE_DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
   const StreamMap::iterator it = stream_map_.find(id);
   if (it != stream_map_.end()) {
     return !it->second->IsZombie();
@@ -2051,8 +2054,9 @@
 }
 
 size_t QuicSession::GetNumActiveStreams() const {
-  DCHECK_GE(static_cast<QuicStreamCount>(stream_map_.size()),
-            num_static_streams_ + num_draining_streams_ + num_zombie_streams_);
+  QUICHE_DCHECK_GE(
+      static_cast<QuicStreamCount>(stream_map_.size()),
+      num_static_streams_ + num_draining_streams_ + num_zombie_streams_);
   return stream_map_.size() - num_draining_streams_ - num_static_streams_ -
          num_zombie_streams_;
 }
@@ -2355,7 +2359,7 @@
     QuicStream* crypto_stream =
         GetStream(QuicUtils::GetCryptoStreamId(transport_version()));
     crypto_stream->OnCanWrite();
-    DCHECK(CheckStreamWriteBlocked(crypto_stream));
+    QUICHE_DCHECK(CheckStreamWriteBlocked(crypto_stream));
     if (crypto_stream->HasPendingRetransmission()) {
       // Connection is write blocked.
       return false;
@@ -2379,7 +2383,7 @@
     QuicStream* stream = GetStream(id);
     if (stream != nullptr) {
       stream->OnCanWrite();
-      DCHECK(CheckStreamWriteBlocked(stream));
+      QUICHE_DCHECK(CheckStreamWriteBlocked(stream));
       if (stream->HasPendingRetransmission()) {
         // Connection is write blocked.
         break;
@@ -2419,7 +2423,7 @@
 }
 
 MessageResult QuicSession::SendMessage(QuicMemSliceSpan message, bool flush) {
-  DCHECK(connection_->connected())
+  QUICHE_DCHECK(connection_->connected())
       << ENDPOINT << "Try to write messages when connection is closed.";
   if (!IsEncryptionEstablished()) {
     return {MESSAGE_STATUS_ENCRYPTION_NOT_ESTABLISHED, 0};
@@ -2580,7 +2584,7 @@
 }
 
 bool QuicSession::ValidateToken(absl::string_view token) const {
-  DCHECK_EQ(perspective_, Perspective::IS_SERVER);
+  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_SERVER);
   if (token.empty() || token[0] != 0) {
     // Validate the prefix for token received in NEW_TOKEN frame.
     return false;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 7c5d9bb..7daec2b 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -367,7 +367,7 @@
   }
 
   QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
-    DCHECK(writev_consumes_all_data_);
+    QUICHE_DCHECK(writev_consumes_all_data_);
     return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
                       GetEncryptionLevelToSendApplicationData());
   }
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index b5cdd31..0649428 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -134,7 +134,7 @@
 }
 
 void PendingStream::OnFinRead() {
-  DCHECK(sequencer_.IsClosed());
+  QUICHE_DCHECK(sequencer_.IsClosed());
 }
 
 void PendingStream::AddBytesConsumed(QuicByteCount bytes) {
@@ -169,7 +169,7 @@
 }
 
 void PendingStream::OnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK_EQ(frame.stream_id, id_);
+  QUICHE_DCHECK_EQ(frame.stream_id, id_);
 
   bool is_stream_too_long =
       (frame.offset > kMaxStreamLength) ||
@@ -220,7 +220,7 @@
 }
 
 void PendingStream::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
-  DCHECK_EQ(frame.stream_id, id_);
+  QUICHE_DCHECK_EQ(frame.stream_id, id_);
 
   if (frame.byte_offset > kMaxStreamLength) {
     // Peer are not suppose to write bytes more than maxium allowed.
@@ -403,9 +403,9 @@
 }
 
 void QuicStream::OnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK_EQ(frame.stream_id, id_);
+  QUICHE_DCHECK_EQ(frame.stream_id, id_);
 
-  DCHECK(!(read_side_closed_ && write_side_closed_));
+  QUICHE_DCHECK(!(read_side_closed_ && write_side_closed_));
 
   if (frame.fin && is_static_) {
     OnUnrecoverableError(QUIC_INVALID_STREAM_ID,
@@ -449,7 +449,7 @@
   if (frame.fin && !fin_received_) {
     fin_received_ = true;
     if (fin_sent_) {
-      DCHECK(!was_draining_);
+      QUICHE_DCHECK(!was_draining_);
       session_->StreamDraining(id_,
                                /*unidirectional=*/type_ != BIDIRECTIONAL);
       was_draining_ = true;
@@ -585,7 +585,7 @@
 }
 
 void QuicStream::OnFinRead() {
-  DCHECK(sequencer_.IsClosed());
+  QUICHE_DCHECK(sequencer_.IsClosed());
   // OnFinRead can be called due to a FIN flag in a headers block, so there may
   // have been no OnStreamFrame call with a FIN in the frame.
   fin_received_ = true;
@@ -596,7 +596,7 @@
 }
 
 void QuicStream::SetFinSent() {
-  DCHECK(!VersionUsesHttp3(transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(transport_version()));
   fin_sent_ = true;
 }
 
@@ -714,7 +714,7 @@
     bool fin,
     EncryptionLevel level,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(session()->use_write_or_buffer_data_at_level());
+  QUICHE_DCHECK(session()->use_write_or_buffer_data_at_level());
   QUIC_RELOADABLE_FLAG_COUNT(quic_use_write_or_buffer_data_at_level);
   return WriteOrBufferDataInner(data, fin, level, ack_listener);
 }
@@ -872,7 +872,7 @@
 }
 
 void QuicStream::MaybeSendStopSending(QuicRstStreamErrorCode error) {
-  DCHECK(session()->split_up_send_rst());
+  QUICHE_DCHECK(session()->split_up_send_rst());
   if (stop_sending_sent_) {
     return;
   }
@@ -885,7 +885,7 @@
   if (session()->version().UsesHttp3()) {
     session()->MaybeSendStopSendingFrame(id(), error);
   } else {
-    DCHECK_EQ(QUIC_STREAM_NO_ERROR, error);
+    QUICHE_DCHECK_EQ(QUIC_STREAM_NO_ERROR, error);
     session()->MaybeSendRstStreamFrame(id(), QUIC_STREAM_NO_ERROR,
                                        stream_bytes_written());
   }
@@ -894,7 +894,7 @@
 }
 
 void QuicStream::MaybeSendRstStream(QuicRstStreamErrorCode error) {
-  DCHECK(session()->split_up_send_rst());
+  QUICHE_DCHECK(session()->split_up_send_rst());
   if (rst_sent_) {
     return;
   }
@@ -910,7 +910,7 @@
 }
 
 bool QuicStream::HasBufferedData() const {
-  DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
+  QUICHE_DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
   return send_buffer_.stream_offset() > stream_bytes_written();
 }
 
@@ -932,7 +932,7 @@
 }
 
 void QuicStream::OnClose() {
-  DCHECK(read_side_closed_ && write_side_closed_);
+  QUICHE_DCHECK(read_side_closed_ && write_side_closed_);
 
   if (!fin_sent_ && !rst_sent_) {
     if (!session()->split_up_send_rst()) {
@@ -1061,7 +1061,7 @@
 
   // The validation code below is for QUIC with TLS only.
   if (new_offset < flow_controller_->send_window_offset()) {
-    DCHECK(session()->version().UsesTls());
+    QUICHE_DCHECK(session()->version().UsesTls());
     if (was_zero_rtt_rejected && new_offset < flow_controller_->bytes_sent()) {
       // The client is given flow control window lower than what's written in
       // 0-RTT. This QUIC implementation is unable to retransmit them.
@@ -1162,8 +1162,8 @@
                                       QuicByteCount data_length,
                                       bool fin,
                                       TransmissionType type) {
-  DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
-         type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
+  QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
+                type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
   if (HasDeadlinePassed()) {
     OnDeadlinePassed();
     return true;
@@ -1230,14 +1230,14 @@
 bool QuicStream::WriteStreamData(QuicStreamOffset offset,
                                  QuicByteCount data_length,
                                  QuicDataWriter* writer) {
-  DCHECK_LT(0u, data_length);
+  QUICHE_DCHECK_LT(0u, data_length);
   QUIC_DVLOG(2) << ENDPOINT << "Write stream " << id_ << " data from offset "
                 << offset << " length " << data_length;
   return send_buffer_.WriteStreamData(offset, data_length, writer);
 }
 
 void QuicStream::WriteBufferedData(absl::optional<EncryptionLevel> level) {
-  DCHECK(!write_side_closed_ && (HasBufferedData() || fin_buffered_));
+  QUICHE_DCHECK(!write_side_closed_ && (HasBufferedData() || fin_buffered_));
 
   if (session_->ShouldYield(id())) {
     session_->MarkConnectionLevelWriteBlocked(id());
@@ -1310,11 +1310,11 @@
       MaybeSendBlocked();
     }
     if (fin && consumed_data.fin_consumed) {
-      DCHECK(!fin_sent_);
+      QUICHE_DCHECK(!fin_sent_);
       fin_sent_ = true;
       fin_outstanding_ = true;
       if (fin_received_) {
-        DCHECK(!was_draining_);
+        QUICHE_DCHECK(!was_draining_);
         session_->StreamDraining(id_,
                                  /*unidirectional=*/type_ != BIDIRECTIONAL);
         was_draining_ = true;
@@ -1332,7 +1332,7 @@
 }
 
 uint64_t QuicStream::BufferedDataBytes() const {
-  DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
+  QUICHE_DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
   return send_buffer_.stream_offset() - stream_bytes_written();
 }
 
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index a6e3518..397eb71 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -47,7 +47,7 @@
 bool QuicStreamIdManager::OnStreamsBlockedFrame(
     const QuicStreamsBlockedFrame& frame,
     std::string* error_details) {
-  DCHECK_EQ(frame.unidirectional, unidirectional_);
+  QUICHE_DCHECK_EQ(frame.unidirectional, unidirectional_);
   if (frame.stream_count > incoming_advertised_max_streams_) {
     // Peer thinks it can send more streams that we've told it.
     *error_details = absl::StrCat(
@@ -55,7 +55,8 @@
         " exceeds incoming max stream ", incoming_advertised_max_streams_);
     return false;
   }
-  DCHECK_LE(incoming_advertised_max_streams_, incoming_actual_max_streams_);
+  QUICHE_DCHECK_LE(incoming_advertised_max_streams_,
+                   incoming_actual_max_streams_);
   if (incoming_advertised_max_streams_ == incoming_actual_max_streams_) {
     // We have told peer about current max.
     return true;
@@ -118,8 +119,8 @@
 }
 
 void QuicStreamIdManager::OnStreamClosed(QuicStreamId stream_id) {
-  DCHECK_NE(QuicUtils::IsBidirectionalStreamId(stream_id, version_),
-            unidirectional_);
+  QUICHE_DCHECK_NE(QuicUtils::IsBidirectionalStreamId(stream_id, version_),
+                   unidirectional_);
   if (QuicUtils::IsOutgoingStreamId(version_, stream_id, perspective_)) {
     // Nothing to do for outgoing streams.
     return;
@@ -149,7 +150,7 @@
 }
 
 bool QuicStreamIdManager::CanOpenNextOutgoingStream() const {
-  DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
   return outgoing_stream_count_ < outgoing_max_streams_;
 }
 
@@ -157,11 +158,11 @@
     const QuicStreamId stream_id,
     std::string* error_details) {
   // |stream_id| must be an incoming stream of the right directionality.
-  DCHECK_NE(QuicUtils::IsBidirectionalStreamId(stream_id, version_),
-            unidirectional_);
-  DCHECK_NE(QuicUtils::IsServerInitiatedStreamId(version_.transport_version,
-                                                 stream_id),
-            perspective_ == Perspective::IS_SERVER);
+  QUICHE_DCHECK_NE(QuicUtils::IsBidirectionalStreamId(stream_id, version_),
+                   unidirectional_);
+  QUICHE_DCHECK_NE(QuicUtils::IsServerInitiatedStreamId(
+                       version_.transport_version, stream_id),
+                   perspective_ == Perspective::IS_SERVER);
   if (available_streams_.erase(stream_id) == 1) {
     // stream_id is available.
     return true;
@@ -169,7 +170,7 @@
 
   if (largest_peer_created_stream_id_ !=
       QuicUtils::GetInvalidStreamId(version_.transport_version)) {
-    DCHECK_GT(stream_id, largest_peer_created_stream_id_);
+    QUICHE_DCHECK_GT(stream_id, largest_peer_created_stream_id_);
   }
 
   // Calculate increment of incoming_stream_count_ by creating stream_id.
@@ -204,7 +205,8 @@
 }
 
 bool QuicStreamIdManager::IsAvailableStream(QuicStreamId id) const {
-  DCHECK_NE(QuicUtils::IsBidirectionalStreamId(id, version_), unidirectional_);
+  QUICHE_DCHECK_NE(QuicUtils::IsBidirectionalStreamId(id, version_),
+                   unidirectional_);
   if (QuicUtils::IsOutgoingStreamId(version_, id, perspective_)) {
     // Stream IDs under next_ougoing_stream_id_ are either open or previously
     // open but now closed.
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 98905ee..47ba76f 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -76,7 +76,7 @@
                            GetParam().version,
                            0,
                            kDefaultMaxStreamsPerConnection) {
-    DCHECK(VersionHasIetfQuicFrames(transport_version()));
+    QUICHE_DCHECK(VersionHasIetfQuicFrames(transport_version()));
   }
 
   QuicTransportVersion transport_version() const {
diff --git a/quic/core/quic_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index f942229..219eacd 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc
@@ -58,7 +58,7 @@
                                           int iov_count,
                                           size_t iov_offset,
                                           QuicByteCount data_length) {
-  DCHECK_LT(0u, data_length);
+  QUICHE_DCHECK_LT(0u, data_length);
   // Latch the maximum data slice size.
   const QuicByteCount max_data_slice_size =
       GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size);
diff --git a/quic/core/quic_stream_sequencer.cc b/quic/core/quic_stream_sequencer.cc
index ae96229..e702f71 100644
--- a/quic/core/quic_stream_sequencer.cc
+++ b/quic/core/quic_stream_sequencer.cc
@@ -47,7 +47,7 @@
 }
 
 void QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK_LE(frame.offset + frame.data_length, close_offset_);
+  QUICHE_DCHECK_LE(frame.offset + frame.data_length, close_offset_);
   ++num_frames_received_;
   const QuicStreamOffset byte_offset = frame.offset;
   const size_t data_len = frame.data_length;
@@ -59,7 +59,7 @@
   if (GetQuicReloadableFlag(quic_accept_empty_stream_frame_with_no_fin)) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_accept_empty_stream_frame_with_no_fin);
     if (stream_->version().HasIetfQuicFrames() && data_len == 0) {
-      DCHECK(!frame.fin);
+      QUICHE_DCHECK(!frame.fin);
       // Ignore empty frame with no fin.
       return;
     }
@@ -178,23 +178,23 @@
 }
 
 int QuicStreamSequencer::GetReadableRegions(iovec* iov, size_t iov_len) const {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   return buffered_frames_.GetReadableRegions(iov, iov_len);
 }
 
 bool QuicStreamSequencer::GetReadableRegion(iovec* iov) const {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   return buffered_frames_.GetReadableRegion(iov);
 }
 
 bool QuicStreamSequencer::PeekRegion(QuicStreamOffset offset,
                                      iovec* iov) const {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   return buffered_frames_.PeekRegion(offset, iov);
 }
 
 void QuicStreamSequencer::Read(std::string* buffer) {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   buffer->resize(buffer->size() + ReadableBytes());
   iovec iov;
   iov.iov_len = ReadableBytes();
@@ -203,7 +203,7 @@
 }
 
 size_t QuicStreamSequencer::Readv(const struct iovec* iov, size_t iov_len) {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   std::string error_details;
   size_t bytes_read;
   QuicErrorCode read_error =
@@ -232,7 +232,7 @@
 }
 
 void QuicStreamSequencer::MarkConsumed(size_t num_bytes_consumed) {
-  DCHECK(!blocked_);
+  QUICHE_DCHECK(!blocked_);
   bool result = buffered_frames_.MarkConsumed(num_bytes_consumed);
   if (!result) {
     QUIC_BUG << "Invalid argument to MarkConsumed."
@@ -274,7 +274,7 @@
 }
 
 void QuicStreamSequencer::FlushBufferedFrames() {
-  DCHECK(ignore_read_data_);
+  QUICHE_DCHECK(ignore_read_data_);
   size_t bytes_flushed = buffered_frames_.FlushBufferedFrames();
   QUIC_DVLOG(1) << "Flushing buffered data at offset "
                 << buffered_frames_.BytesConsumed() << " length "
diff --git a/quic/core/quic_stream_sequencer_buffer.cc b/quic/core/quic_stream_sequencer_buffer.cc
index f1be32c..5c85a6e 100644
--- a/quic/core/quic_stream_sequencer_buffer.cc
+++ b/quic/core/quic_stream_sequencer_buffer.cc
@@ -47,7 +47,7 @@
       total_bytes_read_(0),
       blocks_(nullptr) {
   if (allocate_blocks_on_demand_) {
-    DCHECK_GE(max_blocks_count_, kInitialBlockCount);
+    QUICHE_DCHECK_GE(max_blocks_count_, kInitialBlockCount);
   }
   Clear();
 }
@@ -204,7 +204,7 @@
     const size_t write_block_offset = GetInBlockOffset(offset);
     size_t current_blocks_count =
         allocate_blocks_on_demand_ ? current_blocks_count_ : max_blocks_count_;
-    DCHECK_GT(current_blocks_count, write_block_num);
+    QUICHE_DCHECK_GT(current_blocks_count, write_block_num);
 
     size_t block_capacity = GetBlockCapacity(write_block_num);
     size_t bytes_avail = block_capacity - write_block_offset;
@@ -275,7 +275,7 @@
   *bytes_read = 0;
   for (size_t i = 0; i < dest_count && ReadableBytes() > 0; ++i) {
     char* dest = reinterpret_cast<char*>(dest_iov[i].iov_base);
-    DCHECK(dest != nullptr);
+    QUICHE_DCHECK(dest != nullptr);
     size_t dest_remaining = dest_iov[i].iov_len;
     while (dest_remaining > 0 && ReadableBytes() > 0) {
       size_t block_idx = NextBlockToRead();
@@ -285,7 +285,7 @@
           ReadableBytes(), block_capacity - start_offset_in_block);
       size_t bytes_to_copy =
           std::min<size_t>(bytes_available_in_block, dest_remaining);
-      DCHECK_GT(bytes_to_copy, 0u);
+      QUICHE_DCHECK_GT(bytes_to_copy, 0u);
       if (blocks_[block_idx] == nullptr || dest == nullptr) {
         *error_details = absl::StrCat(
             "QuicStreamSequencerBuffer error:"
@@ -328,8 +328,8 @@
 
 int QuicStreamSequencerBuffer::GetReadableRegions(struct iovec* iov,
                                                   int iov_len) const {
-  DCHECK(iov != nullptr);
-  DCHECK_GT(iov_len, 0);
+  QUICHE_DCHECK(iov != nullptr);
+  QUICHE_DCHECK_GT(iov_len, 0);
 
   if (ReadableBytes() == 0) {
     iov[0].iov_base = nullptr;
@@ -339,7 +339,7 @@
 
   size_t start_block_idx = NextBlockToRead();
   QuicStreamOffset readable_offset_end = FirstMissingByte() - 1;
-  DCHECK_GE(readable_offset_end + 1, total_bytes_read_);
+  QUICHE_DCHECK_GE(readable_offset_end + 1, total_bytes_read_);
   size_t end_block_offset = GetInBlockOffset(readable_offset_end);
   size_t end_block_idx = GetBlockIndex(readable_offset_end);
 
@@ -356,7 +356,7 @@
   iov[0].iov_len = GetBlockCapacity(start_block_idx) - ReadOffset();
   QUIC_DVLOG(1) << "Got first block " << start_block_idx << " with len "
                 << iov[0].iov_len;
-  DCHECK_GT(readable_offset_end + 1, total_bytes_read_ + iov[0].iov_len)
+  QUICHE_DCHECK_GT(readable_offset_end + 1, total_bytes_read_ + iov[0].iov_len)
       << "there should be more available data";
 
   // Get readable regions of the rest blocks till either 2nd to last block
@@ -365,7 +365,7 @@
   int iov_used = 1;
   size_t block_idx = (start_block_idx + iov_used) % max_blocks_count_;
   while (block_idx != end_block_idx && iov_used < iov_len) {
-    DCHECK(nullptr != blocks_[block_idx]);
+    QUICHE_DCHECK(nullptr != blocks_[block_idx]);
     iov[iov_used].iov_base = blocks_[block_idx]->buffer;
     iov[iov_used].iov_len = GetBlockCapacity(block_idx);
     QUIC_DVLOG(1) << "Got block with index: " << block_idx;
@@ -375,7 +375,7 @@
 
   // Deal with last block if |iov| can hold more.
   if (iov_used < iov_len) {
-    DCHECK(nullptr != blocks_[block_idx]);
+    QUICHE_DCHECK(nullptr != blocks_[block_idx]);
     iov[iov_used].iov_base = blocks_[end_block_idx]->buffer;
     iov[iov_used].iov_len = end_block_offset + 1;
     QUIC_DVLOG(1) << "Got last block with index: " << end_block_idx;
@@ -390,7 +390,7 @@
 
 bool QuicStreamSequencerBuffer::PeekRegion(QuicStreamOffset offset,
                                            iovec* iov) const {
-  DCHECK(iov);
+  QUICHE_DCHECK(iov);
 
   if (offset < total_bytes_read_) {
     // Data at |offset| has already been consumed.
@@ -491,7 +491,8 @@
 }
 
 bool QuicStreamSequencerBuffer::RetireBlockIfEmpty(size_t block_index) {
-  DCHECK(ReadableBytes() == 0 || GetInBlockOffset(total_bytes_read_) == 0)
+  QUICHE_DCHECK(ReadableBytes() == 0 ||
+                GetInBlockOffset(total_bytes_read_) == 0)
       << "RetireBlockIfEmpty() should only be called when advancing to next "
       << "block or a gap has been reached.";
   // If the whole buffer becomes empty, the last piece of data has been read.
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index 3c46c41..dc21a09 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -900,7 +900,7 @@
       start_chopping_offset += chunk_size;
       ++iterations;
     }
-    DCHECK(start_chopping_offset == bytes_to_buffer_);
+    QUICHE_DCHECK(start_chopping_offset == bytes_to_buffer_);
     size_t chunk_num = iterations;
 
     // Randomly change the sequence of in-ordered OffsetSizePairs to make a
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index 7725eb9..641f5c9 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -135,13 +135,13 @@
     QuicConnectionId connection_id,
     TimeWaitAction action,
     TimeWaitConnectionInfo info) {
-  DCHECK(!info.active_connection_ids.empty());
+  QUICHE_DCHECK(!info.active_connection_ids.empty());
   const QuicConnectionId& canonical_connection_id =
       use_indirect_connection_id_map_ ? info.active_connection_ids.front()
                                       : connection_id;
-  DCHECK(action != SEND_TERMINATION_PACKETS ||
-         !info.termination_packets.empty());
-  DCHECK(action != DO_NOTHING || info.ietf_quic);
+  QUICHE_DCHECK(action != SEND_TERMINATION_PACKETS ||
+                !info.termination_packets.empty());
+  QUICHE_DCHECK(action != DO_NOTHING || info.ietf_quic);
   int num_packets = 0;
   auto it = FindConnectionIdDataInMap(canonical_connection_id);
   const bool new_connection_id = it == connection_id_map_.end();
@@ -152,8 +152,8 @@
   TrimTimeWaitListIfNeeded();
   int64_t max_connections =
       GetQuicFlag(FLAGS_quic_time_wait_list_max_connections);
-  DCHECK(connection_id_map_.empty() ||
-         num_connections() < static_cast<size_t>(max_connections));
+  QUICHE_DCHECK(connection_id_map_.empty() ||
+                num_connections() < static_cast<size_t>(max_connections));
   if (use_indirect_connection_id_map_ && new_connection_id) {
     QUIC_RESTART_FLAG_COUNT_N(quic_time_wait_list_support_multiple_cid_v2, 3,
                               3);
@@ -193,11 +193,11 @@
     QuicConnectionId connection_id,
     PacketHeaderFormat header_format,
     std::unique_ptr<QuicPerPacketContext> packet_context) {
-  DCHECK(IsConnectionIdInTimeWait(connection_id));
+  QUICHE_DCHECK(IsConnectionIdInTimeWait(connection_id));
   // TODO(satyamshekhar): Think about handling packets from different peer
   // addresses.
   auto it = FindConnectionIdDataInMap(connection_id);
-  DCHECK(it != connection_id_map_.end());
+  QUICHE_DCHECK(it != connection_id_map_.end());
   // Increment the received packet count.
   ConnectionIdData* connection_data = &it->second;
   ++(connection_data->num_packets);
@@ -278,7 +278,7 @@
       return;
     case DO_NOTHING:
       QUIC_CODE_COUNT(quic_time_wait_list_do_nothing);
-      DCHECK(connection_data->info.ietf_quic);
+      QUICHE_DCHECK(connection_data->info.ietf_quic);
   }
 }
 
@@ -402,7 +402,7 @@
 
   if (IsWriteBlockedStatus(result.status)) {
     // If blocked and unbuffered, return false to retry sending.
-    DCHECK(writer_->IsWriteBlocked());
+    QUICHE_DCHECK(writer_->IsWriteBlocked());
     visitor_->OnWriteBlocked(this);
     return result.status == WRITE_STATUS_BLOCKED_DATA_BUFFERED;
   } else if (IsWriteError(result.status)) {
diff --git a/quic/core/quic_trace_visitor_test.cc b/quic/core/quic_trace_visitor_test.cc
index 0371982..5ebaea8 100644
--- a/quic/core/quic_trace_visitor_test.cc
+++ b/quic/core/quic_trace_visitor_test.cc
@@ -48,11 +48,11 @@
     client.AddBytesToTransfer(kTransferSize);
     bool simulator_result = simulator.RunUntilOrTimeout(
         [&]() { return server.bytes_received() >= kTransferSize; }, kDeadline);
-    CHECK(simulator_result);
+    QUICHE_CHECK(simulator_result);
 
     // Save the trace and ensure some loss was observed.
     trace_.Swap(visitor.trace());
-    CHECK_NE(0u, client.connection()->GetStats().packets_retransmitted);
+    QUICHE_CHECK_NE(0u, client.connection()->GetStats().packets_retransmitted);
     packets_sent_ = client.connection()->GetStats().packets_sent;
   }
 
diff --git a/quic/core/quic_udp_socket_posix.cc b/quic/core/quic_udp_socket_posix.cc
index 8b3060d..e410635 100644
--- a/quic/core/quic_udp_socket_posix.cc
+++ b/quic/core/quic_udp_socket_posix.cc
@@ -102,7 +102,7 @@
 
 void SetV4SelfIpInControlMessage(const QuicIpAddress& self_address,
                                  cmsghdr* cmsg) {
-  DCHECK(self_address.IsIPv4());
+  QUICHE_DCHECK(self_address.IsIPv4());
   in_pktinfo* pktinfo = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
   memset(pktinfo, 0, sizeof(in_pktinfo));
   pktinfo->ipi_ifindex = 0;
@@ -113,7 +113,7 @@
 
 void SetV6SelfIpInControlMessage(const QuicIpAddress& self_address,
                                  cmsghdr* cmsg) {
-  DCHECK(self_address.IsIPv6());
+  QUICHE_DCHECK(self_address.IsIPv6());
   in6_pktinfo* pktinfo = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
   memset(pktinfo, 0, sizeof(in6_pktinfo));
   std::string address_string = self_address.ToPackedString();
@@ -212,12 +212,12 @@
   }
 
   if ((*cmsg) == nullptr) {
-    DCHECK_EQ(nullptr, hdr->msg_control);
+    QUICHE_DCHECK_EQ(nullptr, hdr->msg_control);
     memset(control_buffer, 0, control_buffer_len);
     hdr->msg_control = control_buffer;
     (*cmsg) = CMSG_FIRSTHDR(hdr);
   } else {
-    DCHECK_NE(nullptr, hdr->msg_control);
+    QUICHE_DCHECK_NE(nullptr, hdr->msg_control);
     (*cmsg) = CMSG_NXTHDR(hdr, (*cmsg));
   }
 
@@ -237,10 +237,10 @@
                                          int receive_buffer_size,
                                          int send_buffer_size,
                                          bool ipv6_only) {
-  // DCHECK here so the program exits early(before reading packets) in debug
-  // mode. This should have been a static_assert, however it can't be done on
-  // ios/osx because CMSG_SPACE isn't a constant expression there.
-  DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
+  // QUICHE_DCHECK here so the program exits early(before reading packets) in
+  // debug mode. This should have been a static_assert, however it can't be done
+  // on ios/osx because CMSG_SPACE isn't a constant expression there.
+  QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
   QuicUdpSocketFd fd = CreateNonblockingSocket(address_family);
 
   if (fd == kQuicInvalidSocketFd) {
@@ -383,7 +383,7 @@
   BufferSpan& control_buffer = result->control_buffer;
   QuicUdpPacketInfo* packet_info = &result->packet_info;
 
-  DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
+  QUICHE_DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
 
   struct iovec iov = {packet_buffer.buffer, packet_buffer.buffer_len};
   struct sockaddr_storage raw_peer_address;
@@ -488,7 +488,7 @@
     hdr->msg_control = (*results)[i].control_buffer.buffer;
     hdr->msg_controllen = (*results)[i].control_buffer.buffer_len;
 
-    DCHECK_GE(hdr->msg_controllen, kMinCmsgSpaceForRead);
+    QUICHE_DCHECK_GE(hdr->msg_controllen, kMinCmsgSpaceForRead);
   }
   // If MSG_TRUNC is set on Linux, recvmmsg will return the real packet size in
   // |hdrs[i].msg_len| even if packet buffer is too small to receive it.
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index acb30d5..b6872ff 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -153,7 +153,7 @@
               largest_sent_packet_ >= packet_number)
       << "largest_sent_packet_: " << largest_sent_packet_
       << ", packet_number: " << packet_number;
-  DCHECK_GE(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_GE(packet_number, least_unacked_ + unacked_packets_size());
   while (least_unacked_ + unacked_packets_size() < packet_number) {
     unacked_packets_push_back(QuicTransmissionInfo());
     unacked_packets_back().state = NEVER_SENT;
@@ -207,8 +207,8 @@
 
 bool QuicUnackedPacketMap::HasRetransmittableFrames(
     QuicPacketNumber packet_number) const {
-  DCHECK_GE(packet_number, least_unacked_);
-  DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_GE(packet_number, least_unacked_);
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
   return HasRetransmittableFrames(
       unacked_packets_at(packet_number - least_unacked_));
 }
@@ -235,8 +235,8 @@
 
 void QuicUnackedPacketMap::RemoveRetransmittability(
     QuicPacketNumber packet_number) {
-  DCHECK_GE(packet_number, least_unacked_);
-  DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_GE(packet_number, least_unacked_);
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
   QuicTransmissionInfo* info =
       &unacked_packets_at(packet_number - least_unacked_);
   RemoveRetransmittability(info);
@@ -244,7 +244,8 @@
 
 void QuicUnackedPacketMap::IncreaseLargestAcked(
     QuicPacketNumber largest_acked) {
-  DCHECK(!largest_acked_.IsInitialized() || largest_acked_ <= largest_acked);
+  QUICHE_DCHECK(!largest_acked_.IsInitialized() ||
+                largest_acked_ <= largest_acked);
   largest_acked_ = largest_acked;
 }
 
@@ -325,8 +326,8 @@
 }
 
 void QuicUnackedPacketMap::RemoveFromInFlight(QuicPacketNumber packet_number) {
-  DCHECK_GE(packet_number, least_unacked_);
-  DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_GE(packet_number, least_unacked_);
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
   QuicTransmissionInfo* info =
       &unacked_packets_at(packet_number - least_unacked_);
   RemoveFromInFlight(info);
@@ -351,11 +352,12 @@
       // send algorithm).
       // TODO(b/148868195): use NotifyFramesNeutered.
       NotifyFramesAcked(*it, QuicTime::Delta::Zero(), QuicTime::Zero());
-      DCHECK(!HasRetransmittableFrames(*it));
+      QUICHE_DCHECK(!HasRetransmittableFrames(*it));
     }
   }
-  DCHECK(!supports_multiple_packet_number_spaces_ ||
-         last_inflight_packets_sent_time_[INITIAL_DATA] == QuicTime::Zero());
+  QUICHE_DCHECK(!supports_multiple_packet_number_spaces_ ||
+                last_inflight_packets_sent_time_[INITIAL_DATA] ==
+                    QuicTime::Zero());
   return neutered_packets;
 }
 
@@ -377,8 +379,9 @@
       NotifyFramesAcked(*it, QuicTime::Delta::Zero(), QuicTime::Zero());
     }
   }
-  DCHECK(!supports_multiple_packet_number_spaces() ||
-         last_inflight_packets_sent_time_[HANDSHAKE_DATA] == QuicTime::Zero());
+  QUICHE_DCHECK(!supports_multiple_packet_number_spaces() ||
+                last_inflight_packets_sent_time_[HANDSHAKE_DATA] ==
+                    QuicTime::Zero());
   return neutered_packets;
 }
 
@@ -593,13 +596,13 @@
 
 const QuicTransmissionInfo*
 QuicUnackedPacketMap::GetFirstInFlightTransmissionInfo() const {
-  DCHECK(HasInFlightPackets());
+  QUICHE_DCHECK(HasInFlightPackets());
   for (auto it = begin(); it != end(); ++it) {
     if (it->in_flight) {
       return &(*it);
     }
   }
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index a024fe8..eb6b0a6 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -136,7 +136,7 @@
   void RetransmitAndSendPacket(uint64_t old_packet_number,
                                uint64_t new_packet_number,
                                TransmissionType transmission_type) {
-    DCHECK(unacked_packets_.HasRetransmittableFrames(
+    QUICHE_DCHECK(unacked_packets_.HasRetransmittableFrames(
         QuicPacketNumber(old_packet_number)));
     QuicTransmissionInfo* info = unacked_packets_.GetMutableTransmissionInfo(
         QuicPacketNumber(old_packet_number));
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index f044cef..7eff759 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -244,8 +244,8 @@
     iov_offset -= iov[iovnum].iov_len;
     ++iovnum;
   }
-  DCHECK_LE(iovnum, iov_count);
-  DCHECK_LE(iov_offset, iov[iovnum].iov_len);
+  QUICHE_DCHECK_LE(iovnum, iov_count);
+  QUICHE_DCHECK_LE(iov_offset, iov[iovnum].iov_len);
   if (iovnum >= iov_count || buffer_length == 0) {
     return;
   }
@@ -397,7 +397,7 @@
 
 // static
 QuicStreamId QuicUtils::GetHeadersStreamId(QuicTransportVersion version) {
-  DCHECK(!VersionUsesHttp3(version));
+  QUICHE_DCHECK(!VersionUsesHttp3(version));
   return GetFirstBidirectionalStreamId(version, Perspective::IS_CLIENT);
 }
 
@@ -435,7 +435,7 @@
 // static
 bool QuicUtils::IsBidirectionalStreamId(QuicStreamId id,
                                         ParsedQuicVersion version) {
-  DCHECK(version.HasIetfQuicFrames());
+  QUICHE_DCHECK(version.HasIetfQuicFrames());
   return id % 4 < 2;
 }
 
@@ -444,26 +444,26 @@
                                     Perspective perspective,
                                     bool peer_initiated,
                                     ParsedQuicVersion version) {
-  DCHECK(version.HasIetfQuicFrames());
+  QUICHE_DCHECK(version.HasIetfQuicFrames());
   if (IsBidirectionalStreamId(id, version)) {
     return BIDIRECTIONAL;
   }
 
   if (peer_initiated) {
     if (perspective == Perspective::IS_SERVER) {
-      DCHECK_EQ(2u, id % 4);
+      QUICHE_DCHECK_EQ(2u, id % 4);
     } else {
-      DCHECK_EQ(Perspective::IS_CLIENT, perspective);
-      DCHECK_EQ(3u, id % 4);
+      QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective);
+      QUICHE_DCHECK_EQ(3u, id % 4);
     }
     return READ_UNIDIRECTIONAL;
   }
 
   if (perspective == Perspective::IS_SERVER) {
-    DCHECK_EQ(3u, id % 4);
+    QUICHE_DCHECK_EQ(3u, id % 4);
   } else {
-    DCHECK_EQ(Perspective::IS_CLIENT, perspective);
-    DCHECK_EQ(2u, id % 4);
+    QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective);
+    QUICHE_DCHECK_EQ(2u, id % 4);
   }
   return WRITE_UNIDIRECTIONAL;
 }
@@ -665,7 +665,7 @@
     case APPLICATION_DATA:
       return ENCRYPTION_FORWARD_SECURE;
     default:
-      DCHECK(false);
+      QUICHE_DCHECK(false);
       return NUM_ENCRYPTION_LEVELS;
   }
 }
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index 9b61f0f..a5249d7 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -141,7 +141,7 @@
     } else if (i == ALL_INITIAL_RETRANSMISSION) {
       EXPECT_EQ(UNACKABLE, state);
     } else {
-      DCHECK(false)
+      QUICHE_DCHECK(false)
           << "No corresponding packet state according to transmission type: "
           << i;
     }
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 5dee155..5320dd9 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -65,121 +65,121 @@
 }  // namespace
 
 bool ParsedQuicVersion::IsKnown() const {
-  DCHECK(ParsedQuicVersionIsValid(handshake_protocol, transport_version))
+  QUICHE_DCHECK(ParsedQuicVersionIsValid(handshake_protocol, transport_version))
       << QuicVersionToString(transport_version) << " "
       << HandshakeProtocolToString(handshake_protocol);
   return transport_version != QUIC_VERSION_UNSUPPORTED;
 }
 
 bool ParsedQuicVersion::KnowsWhichDecrypterToUse() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::UsesInitialObfuscators() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // Initial obfuscators were added in version 50.
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::AllowsLowFlowControlLimits() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // Low flow-control limits are used for all IETF versions.
   return UsesHttp3();
 }
 
 bool ParsedQuicVersion::HasHeaderProtection() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // Header protection was added in version 50.
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::SupportsRetry() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // Retry was added in version 47.
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::SendsVariableLengthPacketNumberInLongHeader() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::AllowsVariableLengthConnectionIds() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionAllowsVariableLengthConnectionIds(transport_version);
 }
 
 bool ParsedQuicVersion::SupportsClientConnectionIds() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // Client connection IDs were added in version 49.
   return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::HasLengthPrefixedConnectionIds() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionHasLengthPrefixedConnectionIds(transport_version);
 }
 
 bool ParsedQuicVersion::SupportsAntiAmplificationLimit() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   // The anti-amplification limit is used for all IETF versions.
   return UsesHttp3();
 }
 
 bool ParsedQuicVersion::CanSendCoalescedPackets() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return HasLongHeaderLengths() && UsesTls();
 }
 
 bool ParsedQuicVersion::SupportsGoogleAltSvcFormat() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionSupportsGoogleAltSvcFormat(transport_version);
 }
 
 bool ParsedQuicVersion::HasIetfInvariantHeader() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionHasIetfInvariantHeader(transport_version);
 }
 
 bool ParsedQuicVersion::SupportsMessageFrames() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionSupportsMessageFrames(transport_version);
 }
 
 bool ParsedQuicVersion::UsesHttp3() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionUsesHttp3(transport_version);
 }
 
 bool ParsedQuicVersion::HasLongHeaderLengths() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return QuicVersionHasLongHeaderLengths(transport_version);
 }
 
 bool ParsedQuicVersion::UsesCryptoFrames() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return QuicVersionUsesCryptoFrames(transport_version);
 }
 
 bool ParsedQuicVersion::HasIetfQuicFrames() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return VersionHasIetfQuicFrames(transport_version);
 }
 
 bool ParsedQuicVersion::UsesTls() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return handshake_protocol == PROTOCOL_TLS1_3;
 }
 
 bool ParsedQuicVersion::UsesQuicCrypto() const {
-  DCHECK(IsKnown());
+  QUICHE_DCHECK(IsKnown());
   return handshake_protocol == PROTOCOL_QUIC_CRYPTO;
 }
 
 bool VersionHasLengthPrefixedConnectionIds(
     QuicTransportVersion transport_version) {
-  DCHECK(transport_version != QUIC_VERSION_UNSUPPORTED);
+  QUICHE_DCHECK(transport_version != QUIC_VERSION_UNSUPPORTED);
   // Length-prefixed connection IDs were added in version 49.
   return transport_version > QUIC_VERSION_46;
 }
@@ -479,7 +479,7 @@
     return "0";
   }
   if (version == ParsedQuicVersion::Draft29()) {
-    DCHECK(version.UsesHttp3());
+    QUICHE_DCHECK(version.UsesHttp3());
     return "draft29";
   }
 
@@ -522,7 +522,7 @@
 
 bool VersionAllowsVariableLengthConnectionIds(
     QuicTransportVersion transport_version) {
-  DCHECK_NE(transport_version, QUIC_VERSION_UNSUPPORTED);
+  QUICHE_DCHECK_NE(transport_version, QUIC_VERSION_UNSUPPORTED);
   return transport_version > QUIC_VERSION_46;
 }
 
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index 02b72e3..084241d 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -66,9 +66,9 @@
     QuicStreamId stream_id,
     bool is_static_stream,
     const spdy::SpdyStreamPrecedence& precedence) {
-  DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id))
+  QUICHE_DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id))
       << "stream " << stream_id << " already registered";
-  DCHECK(precedence.is_spdy3_priority());
+  QUICHE_DCHECK(precedence.is_spdy3_priority());
   if (is_static_stream) {
     static_stream_collection_.Register(stream_id);
     return;
@@ -89,8 +89,8 @@
 void QuicWriteBlockedList::UpdateStreamPriority(
     QuicStreamId stream_id,
     const spdy::SpdyStreamPrecedence& new_precedence) {
-  DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-  DCHECK(new_precedence.is_spdy3_priority());
+  QUICHE_DCHECK(!static_stream_collection_.IsRegistered(stream_id));
+  QUICHE_DCHECK(new_precedence.is_spdy3_priority());
   priority_write_scheduler_.UpdateStreamPrecedence(stream_id, new_precedence);
 }
 
@@ -126,7 +126,7 @@
 }
 
 void QuicWriteBlockedList::StaticStreamCollection::Register(QuicStreamId id) {
-  DCHECK(!IsRegistered(id));
+  QUICHE_DCHECK(!IsRegistered(id));
   streams_.push_back({id, false});
 }
 
@@ -150,7 +150,7 @@
       return;
     }
   }
-  DCHECK(false) << "Erasing a non-exist stream with id " << id;
+  QUICHE_DCHECK(false) << "Erasing a non-exist stream with id " << id;
 }
 
 bool QuicWriteBlockedList::StaticStreamCollection::SetBlocked(QuicStreamId id) {
diff --git a/quic/core/tls_chlo_extractor.cc b/quic/core/tls_chlo_extractor.cc
index 89aaea8..e03d7db 100644
--- a/quic/core/tls_chlo_extractor.cc
+++ b/quic/core/tls_chlo_extractor.cc
@@ -43,7 +43,7 @@
     std::pair<SSL_CTX*, int> shared_handles = GetSharedSslHandles();
     int ex_data_index = shared_handles.second;
     const int rv = SSL_set_ex_data(ssl_.get(), ex_data_index, this);
-    CHECK_EQ(rv, 1) << "Internal allocation failure in SSL_set_ex_data";
+    QUICHE_CHECK_EQ(rv, 1) << "Internal allocation failure in SSL_set_ex_data";
   }
   state_ = other.state_;
   error_details_ = std::move(other.error_details_);
@@ -355,7 +355,7 @@
 
   ssl_ = bssl::UniquePtr<SSL>(SSL_new(ssl_ctx));
   const int rv = SSL_set_ex_data(ssl_.get(), ex_data_index, this);
-  CHECK_EQ(rv, 1) << "Internal allocation failure in SSL_set_ex_data";
+  QUICHE_CHECK_EQ(rv, 1) << "Internal allocation failure in SSL_set_ex_data";
   SSL_set_accept_state(ssl_.get());
 }
 
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index e82e94d..b878ab8 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -223,7 +223,7 @@
           session()->connection()->version(), Perspective::IS_SERVER,
           param_bytes, param_bytes_len, received_transport_params_.get(),
           &parse_error_details)) {
-    DCHECK(!parse_error_details.empty());
+    QUICHE_DCHECK(!parse_error_details.empty());
     *error_details =
         "Unable to parse server's transport parameters: " + parse_error_details;
     return false;
@@ -256,7 +256,7 @@
       handshaker_delegate()->ProcessTransportParameters(
           *received_transport_params_, /* is_resumption = */ false,
           error_details) != QUIC_NO_ERROR) {
-    DCHECK(!error_details->empty());
+    QUICHE_DCHECK(!error_details->empty());
     return false;
   }
 
@@ -395,7 +395,7 @@
 }
 
 void TlsClientHandshaker::OnHandshakeConfirmed() {
-  DCHECK(one_rtt_keys_available());
+  QUICHE_DCHECK(one_rtt_keys_available());
   if (state_ >= HANDSHAKE_CONFIRMED) {
     return;
   }
@@ -457,7 +457,7 @@
 
   std::string error_details;
   if (!ProcessTransportParameters(&error_details)) {
-    DCHECK(!error_details.empty());
+    QUICHE_DCHECK(!error_details.empty());
     CloseConnection(QUIC_HANDSHAKE_FAILED, error_details);
     return;
   }
@@ -528,7 +528,7 @@
 
 void TlsClientHandshaker::HandleZeroRttReject() {
   QUIC_LOG(INFO) << "0-RTT handshake attempted but was rejected by the server";
-  DCHECK(session_cache_);
+  QUICHE_DCHECK(session_cache_);
   // Disable encrytion to block outgoing data until 1-RTT keys are available.
   encryption_established_ = false;
   handshaker_delegate()->OnZeroRttRejected(EarlyDataReason());
@@ -569,7 +569,7 @@
 
 void TlsClientHandshaker::SetServerApplicationStateForResumption(
     std::unique_ptr<ApplicationState> application_state) {
-  DCHECK(one_rtt_keys_available());
+  QUICHE_DCHECK(one_rtt_keys_available());
   received_application_state_ = std::move(application_state);
   // At least one tls session is cached before application state is received. So
   // insert now.
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index d0079c5..133c85c 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -114,7 +114,7 @@
 
 void TlsHandshaker::CloseConnection(QuicErrorCode error,
                                     const std::string& reason_phrase) {
-  DCHECK(!reason_phrase.empty());
+  QUICHE_DCHECK(!reason_phrase.empty());
   stream()->OnUnrecoverableError(error, reason_phrase);
   is_connection_closed_ = true;
 }
@@ -122,7 +122,7 @@
 void TlsHandshaker::CloseConnection(QuicErrorCode error,
                                     QuicIetfTransportErrorCodes ietf_error,
                                     const std::string& reason_phrase) {
-  DCHECK(!reason_phrase.empty());
+  QUICHE_DCHECK(!reason_phrase.empty());
   stream()->OnUnrecoverableError(error, ietf_error, reason_phrase);
   is_connection_closed_ = true;
 }
@@ -212,7 +212,7 @@
       absl::string_view(reinterpret_cast<char*>(header_protection_key.data()),
                         header_protection_key.size()));
   if (level == ENCRYPTION_FORWARD_SECURE) {
-    DCHECK(latest_write_secret_.empty());
+    QUICHE_DCHECK(latest_write_secret_.empty());
     latest_write_secret_ = write_secret;
     one_rtt_write_header_protection_key_ = header_protection_key;
   }
@@ -235,7 +235,7 @@
       absl::string_view(reinterpret_cast<char*>(header_protection_key.data()),
                         header_protection_key.size()));
   if (level == ENCRYPTION_FORWARD_SECURE) {
-    DCHECK(latest_read_secret_.empty());
+    QUICHE_DCHECK(latest_read_secret_.empty());
     latest_read_secret_ = read_secret;
     one_rtt_read_header_protection_key_ = header_protection_key;
   }
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index 48710c1..02fceed 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -111,7 +111,7 @@
 TlsServerHandshaker::SignatureCallback::SignatureCallback(
     TlsServerHandshaker* handshaker)
     : handshaker_(handshaker) {
-  DCHECK(!handshaker_->use_proof_source_handle_);
+  QUICHE_DCHECK(!handshaker_->use_proof_source_handle_);
 }
 
 void TlsServerHandshaker::SignatureCallback::Run(
@@ -169,7 +169,7 @@
 }
 
 void TlsServerHandshaker::DecryptCallback::Cancel() {
-  DCHECK(handshaker_);
+  QUICHE_DCHECK(handshaker_);
   handshaker_ = nullptr;
 }
 
@@ -183,8 +183,8 @@
       crypto_negotiated_params_(new QuicCryptoNegotiatedParameters),
       tls_connection_(crypto_config->ssl_ctx(), this),
       crypto_config_(crypto_config) {
-  DCHECK_EQ(PROTOCOL_TLS1_3,
-            session->connection()->version().handshake_protocol);
+  QUICHE_DCHECK_EQ(PROTOCOL_TLS1_3,
+                   session->connection()->version().handshake_protocol);
 
   // Configure the SSL to be a server.
   SSL_set_accept_state(ssl());
@@ -214,7 +214,7 @@
 
 std::unique_ptr<ProofSourceHandle>
 TlsServerHandshaker::MaybeCreateProofSourceHandle() {
-  DCHECK(use_proof_source_handle_);
+  QUICHE_DCHECK(use_proof_source_handle_);
   return std::make_unique<DefaultProofSourceHandle>(this, proof_source_);
 }
 
@@ -263,11 +263,11 @@
 }
 
 void TlsServerHandshaker::OnHandshakeDoneReceived() {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 void TlsServerHandshaker::OnNewTokenReceived(absl::string_view /*token*/) {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 std::string TlsServerHandshaker::GetAddressToken() const {
@@ -388,7 +388,7 @@
       params_bytes_len = 0;
     }
   } else {
-    DCHECK_EQ(client_hello, nullptr);
+    QUICHE_DCHECK_EQ(client_hello, nullptr);
     SSL_get_peer_quic_transport_params(ssl(), &client_params_bytes,
                                        &params_bytes_len);
   }
@@ -402,7 +402,7 @@
                                 Perspective::IS_CLIENT, client_params_bytes,
                                 params_bytes_len, &client_params,
                                 &parse_error_details)) {
-    DCHECK(!parse_error_details.empty());
+    QUICHE_DCHECK(!parse_error_details.empty());
     *error_details =
         "Unable to parse client's transport parameters: " + parse_error_details;
     return false;
@@ -451,7 +451,7 @@
 TlsServerHandshaker::SetTransportParametersResult
 TlsServerHandshaker::SetTransportParameters() {
   SetTransportParametersResult result;
-  DCHECK(!result.success);
+  QUICHE_DCHECK(!result.success);
 
   TransportParameters server_params;
   server_params.perspective = Perspective::IS_SERVER;
@@ -580,7 +580,7 @@
     size_t max_out,
     uint16_t sig_alg,
     absl::string_view in) {
-  DCHECK_EQ(expected_ssl_error(), SSL_ERROR_WANT_READ);
+  QUICHE_DCHECK_EQ(expected_ssl_error(), SSL_ERROR_WANT_READ);
   if (use_proof_source_handle_) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_tls_use_per_handshaker_proof_source, 2,
                                  3);
@@ -631,7 +631,7 @@
   QUIC_DVLOG(1) << "OnComputeSignatureDone. ok:" << ok
                 << ", is_sync:" << is_sync
                 << ", len(signature):" << signature.size();
-  DCHECK(use_proof_source_handle_);
+  QUICHE_DCHECK(use_proof_source_handle_);
   if (ok) {
     cert_verify_sig_ = std::move(signature);
     proof_source_details_ = std::move(details);
@@ -639,7 +639,8 @@
   const int last_expected_ssl_error = expected_ssl_error();
   set_expected_ssl_error(SSL_ERROR_WANT_READ);
   if (!is_sync) {
-    DCHECK_EQ(last_expected_ssl_error, SSL_ERROR_WANT_PRIVATE_KEY_OPERATION);
+    QUICHE_DCHECK_EQ(last_expected_ssl_error,
+                     SSL_ERROR_WANT_PRIVATE_KEY_OPERATION);
     AdvanceHandshakeFromCallback();
   }
 }
@@ -650,7 +651,7 @@
 }
 
 size_t TlsServerHandshaker::SessionTicketMaxOverhead() {
-  DCHECK(proof_source_->GetTicketCrypter());
+  QUICHE_DCHECK(proof_source_->GetTicketCrypter());
   return proof_source_->GetTicketCrypter()->MaxOverhead();
 }
 
@@ -658,7 +659,7 @@
                                            size_t* out_len,
                                            size_t max_out_len,
                                            absl::string_view in) {
-  DCHECK(proof_source_->GetTicketCrypter());
+  QUICHE_DCHECK(proof_source_->GetTicketCrypter());
   std::vector<uint8_t> ticket = proof_source_->GetTicketCrypter()->Encrypt(in);
   if (max_out_len < ticket.size()) {
     QUIC_BUG
@@ -677,7 +678,7 @@
     size_t* out_len,
     size_t max_out_len,
     absl::string_view in) {
-  DCHECK(proof_source_->GetTicketCrypter());
+  QUICHE_DCHECK(proof_source_->GetTicketCrypter());
 
   if (!ticket_decryption_callback_) {
     ticket_received_ = true;
@@ -788,7 +789,7 @@
         set_transport_params_result.quic_transport_params,
         set_transport_params_result.early_data_context);
 
-    DCHECK_EQ(status, select_cert_status().value());
+    QUICHE_DCHECK_EQ(status, select_cert_status().value());
 
     if (status == QUIC_PENDING) {
       set_expected_ssl_error(SSL_ERROR_PENDING_CERTIFICATE);
@@ -838,7 +839,7 @@
     const ProofSource::Chain* chain) {
   QUIC_DVLOG(1) << "OnSelectCertificateDone. ok:" << ok
                 << ", is_sync:" << is_sync;
-  DCHECK(use_proof_source_handle_);
+  QUICHE_DCHECK(use_proof_source_handle_);
 
   select_cert_status_ = QUIC_FAILURE;
   if (ok) {
@@ -852,7 +853,7 @@
   const int last_expected_ssl_error = expected_ssl_error();
   set_expected_ssl_error(SSL_ERROR_WANT_READ);
   if (!is_sync) {
-    DCHECK_EQ(last_expected_ssl_error, SSL_ERROR_PENDING_CERTIFICATE);
+    QUICHE_DCHECK_EQ(last_expected_ssl_error, SSL_ERROR_PENDING_CERTIFICATE);
     AdvanceHandshakeFromCallback();
   }
 }
diff --git a/quic/core/tls_server_handshaker_test.cc b/quic/core/tls_server_handshaker_test.cc
index e2cb745..cf1bbc0 100644
--- a/quic/core/tls_server_handshaker_test.cc
+++ b/quic/core/tls_server_handshaker_test.cc
@@ -125,8 +125,8 @@
                                                                  crypto_config);
     }
 
-    CHECK(false) << "Unsupported handshake protocol: "
-                 << connection()->version().handshake_protocol;
+    QUICHE_CHECK(false) << "Unsupported handshake protocol: "
+                        << connection()->version().handshake_protocol;
     return nullptr;
   }
 };
@@ -191,7 +191,7 @@
     // strike register worries that we've just overflowed a uint32_t time.
     server_connection_->AdvanceTime(QuicTime::Delta::FromSeconds(100000));
 
-    CHECK(server_session);
+    QUICHE_CHECK(server_session);
     server_session_.reset(server_session);
   }
 
@@ -226,7 +226,7 @@
         helpers_.back().get(), alarm_factories_.back().get(),
         server_crypto_config_.get(), &server_compressed_certs_cache_,
         &server_connection_, &server_session);
-    CHECK(server_session);
+    QUICHE_CHECK(server_session);
     server_session_.reset(server_session);
     server_handshaker_ = nullptr;
     EXPECT_CALL(*server_session_->helper(), CanAcceptClientHello(_, _, _, _, _))
@@ -264,7 +264,7 @@
         AlpnForVersion(client_connection_->version());
     ON_CALL(*client_session, GetAlpnsToOffer())
         .WillByDefault(Return(std::vector<std::string>({default_alpn})));
-    CHECK(client_session);
+    QUICHE_CHECK(client_session);
     client_session_.reset(client_session);
     moved_messages_counts_ = {0, 0};
   }
@@ -282,8 +282,8 @@
   // Performs a single round of handshake message-exchange between the
   // client and server.
   void AdvanceHandshakeWithFakeClient() {
-    CHECK(server_connection_);
-    CHECK(client_session_ != nullptr);
+    QUICHE_CHECK(server_connection_);
+    QUICHE_CHECK(client_session_ != nullptr);
 
     EXPECT_CALL(*client_session_, OnProofValid(_)).Times(testing::AnyNumber());
     EXPECT_CALL(*client_session_, OnProofVerifyDetailsAvailable(_))
diff --git a/quic/core/uber_received_packet_manager.cc b/quic/core/uber_received_packet_manager.cc
index 432c357..7235edf 100644
--- a/quic/core/uber_received_packet_manager.cc
+++ b/quic/core/uber_received_packet_manager.cc
@@ -189,7 +189,7 @@
 
 QuicPacketNumber UberReceivedPacketManager::peer_least_packet_awaiting_ack()
     const {
-  DCHECK(!supports_multiple_packet_number_spaces_);
+  QUICHE_DCHECK(!supports_multiple_packet_number_spaces_);
   return received_packet_managers_[0].peer_least_packet_awaiting_ack();
 }
 
@@ -211,13 +211,13 @@
 }
 
 const QuicAckFrame& UberReceivedPacketManager::ack_frame() const {
-  DCHECK(!supports_multiple_packet_number_spaces_);
+  QUICHE_DCHECK(!supports_multiple_packet_number_spaces_);
   return received_packet_managers_[0].ack_frame();
 }
 
 const QuicAckFrame& UberReceivedPacketManager::GetAckFrame(
     PacketNumberSpace packet_number_space) const {
-  DCHECK(supports_multiple_packet_number_spaces_);
+  QUICHE_DCHECK(supports_multiple_packet_number_spaces_);
   return received_packet_managers_[packet_number_space].ack_frame();
 }
 
diff --git a/quic/core/uber_received_packet_manager_test.cc b/quic/core/uber_received_packet_manager_test.cc
index 0f8959a..05e4a33 100644
--- a/quic/core/uber_received_packet_manager_test.cc
+++ b/quic/core/uber_received_packet_manager_test.cc
@@ -89,17 +89,17 @@
   }
 
   void CheckAckTimeout(QuicTime time) {
-    DCHECK(HasPendingAck());
+    QUICHE_DCHECK(HasPendingAck());
     if (!manager_->supports_multiple_packet_number_spaces()) {
-      DCHECK(manager_->GetAckTimeout(APPLICATION_DATA) == time);
+      QUICHE_DCHECK(manager_->GetAckTimeout(APPLICATION_DATA) == time);
       if (time <= clock_.ApproximateNow()) {
         // ACK timeout expires, send an ACK.
         manager_->ResetAckStates(ENCRYPTION_FORWARD_SECURE);
-        DCHECK(!HasPendingAck());
+        QUICHE_DCHECK(!HasPendingAck());
       }
       return;
     }
-    DCHECK(manager_->GetEarliestAckTimeout() == time);
+    QUICHE_DCHECK(manager_->GetEarliestAckTimeout() == time);
     // Send all expired ACKs.
     for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
       const QuicTime ack_timeout =
diff --git a/quic/masque/masque_client_session.cc b/quic/masque/masque_client_session.cc
index cb56346..eeedccf 100644
--- a/quic/masque/masque_client_session.cc
+++ b/quic/masque/masque_client_session.cc
@@ -74,10 +74,11 @@
     EncapsulatedClientSession* encapsulated_client_session) {
   QUIC_DLOG(INFO) << "Registering " << client_connection_id
                   << " to encapsulated client";
-  DCHECK(client_connection_id_registrations_.find(client_connection_id) ==
-             client_connection_id_registrations_.end() ||
-         client_connection_id_registrations_[client_connection_id] ==
-             encapsulated_client_session);
+  QUICHE_DCHECK(
+      client_connection_id_registrations_.find(client_connection_id) ==
+          client_connection_id_registrations_.end() ||
+      client_connection_id_registrations_[client_connection_id] ==
+          encapsulated_client_session);
   client_connection_id_registrations_[client_connection_id] =
       encapsulated_client_session;
 }
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
index abf0636..af6758a 100644
--- a/quic/masque/masque_compression_engine.cc
+++ b/quic/masque/masque_compression_engine.cc
@@ -63,7 +63,7 @@
     }
 
     flow_id = kv.first;
-    DCHECK_NE(flow_id, kFlowId0);
+    QUICHE_DCHECK_NE(flow_id, kFlowId0);
     *validated = context.validated;
     QUIC_DVLOG(1) << "Compressing using " << (*validated ? "" : "un")
                   << "validated flow_id " << flow_id << " to "
@@ -133,9 +133,9 @@
       return false;
     }
     QuicIpAddress peer_ip = server_address.host();
-    DCHECK(peer_ip.IsInitialized());
+    QUICHE_DCHECK(peer_ip.IsInitialized());
     std::string peer_ip_bytes = peer_ip.ToPackedString();
-    DCHECK(!peer_ip_bytes.empty());
+    QUICHE_DCHECK(!peer_ip_bytes.empty());
     uint8_t address_id;
     if (peer_ip.address_family() == IpAddressFamily::IP_V6) {
       address_id = MasqueAddressFamilyIPv6;
@@ -229,7 +229,7 @@
   QUIC_DVLOG(2) << "Compressing client " << client_connection_id << " server "
                 << server_connection_id << "\n"
                 << quiche::QuicheTextUtils::HexDump(packet);
-  DCHECK(server_address.IsInitialized());
+  QUICHE_DCHECK(server_address.IsInitialized());
   if (packet.empty()) {
     QUIC_BUG << "Tried to send empty packet";
     return;
diff --git a/quic/masque/masque_encapsulated_epoll_client.cc b/quic/masque/masque_encapsulated_epoll_client.cc
index 1b1723c..8fb938d 100644
--- a/quic/masque/masque_encapsulated_epoll_client.cc
+++ b/quic/masque/masque_encapsulated_epoll_client.cc
@@ -24,7 +24,7 @@
                           const QuicIpAddress& /*self_address*/,
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* /*options*/) override {
-    DCHECK(peer_address.IsInitialized());
+    QUICHE_DCHECK(peer_address.IsInitialized());
     QUIC_DVLOG(1) << "MasquePacketWriter trying to write " << buf_len
                   << " bytes to " << peer_address;
     absl::string_view packet(buffer, buf_len);
diff --git a/quic/masque/masque_utils.cc b/quic/masque/masque_utils.cc
index f8a7a39..f4f77f5 100644
--- a/quic/masque/masque_utils.cc
+++ b/quic/masque/masque_utils.cc
@@ -16,7 +16,7 @@
       break;
     }
   }
-  CHECK(version.IsKnown());
+  QUICHE_CHECK(version.IsKnown());
   QuicEnableVersion(version);
   return {version};
 }
diff --git a/quic/platform/api/quic_ip_address.cc b/quic/platform/api/quic_ip_address.cc
index 42f528f..95877f4 100644
--- a/quic/platform/api/quic_ip_address.cc
+++ b/quic/platform/api/quic_ip_address.cc
@@ -10,6 +10,7 @@
 #include <string>
 
 #include "quic/platform/api/quic_bug_tracker.h"
+#include "quic/platform/api/quic_logging.h"
 
 namespace quic {
 
@@ -217,18 +218,18 @@
   if (bits_to_check == 0) {
     return true;
   }
-  DCHECK_LT(static_cast<size_t>(bytes_to_check), sizeof(address_.bytes));
+  QUICHE_DCHECK_LT(static_cast<size_t>(bytes_to_check), sizeof(address_.bytes));
   int mask = (~0u) << (8u - bits_to_check);
   return (lhs[bytes_to_check] & mask) == (rhs[bytes_to_check] & mask);
 }
 
 in_addr QuicIpAddress::GetIPv4() const {
-  DCHECK(IsIPv4());
+  QUICHE_DCHECK(IsIPv4());
   return address_.v4;
 }
 
 in6_addr QuicIpAddress::GetIPv6() const {
-  DCHECK(IsIPv6());
+  QUICHE_DCHECK(IsIPv6());
   return address_.v6;
 }
 
diff --git a/quic/qbone/bonnet/icmp_reachable_test.cc b/quic/qbone/bonnet/icmp_reachable_test.cc
index 693018d..ae246b7 100644
--- a/quic/qbone/bonnet/icmp_reachable_test.cc
+++ b/quic/qbone/bonnet/icmp_reachable_test.cc
@@ -27,7 +27,7 @@
 constexpr int kFakeWriteFd = 0;
 
 icmp6_hdr GetHeaderFromPacket(const void* buf, size_t len) {
-  CHECK_GE(len, sizeof(ip6_hdr) + sizeof(icmp6_hdr));
+  QUICHE_CHECK_GE(len, sizeof(ip6_hdr) + sizeof(icmp6_hdr));
 
   auto* buffer = reinterpret_cast<const char*>(buf);
   return *reinterpret_cast<const icmp6_hdr*>(&buffer[sizeof(ip6_hdr)]);
@@ -80,11 +80,11 @@
 class IcmpReachableTest : public QuicTest {
  public:
   IcmpReachableTest() {
-    CHECK(source_.FromString(kSourceAddress));
-    CHECK(destination_.FromString(kDestinationAddress));
+    QUICHE_CHECK(source_.FromString(kSourceAddress));
+    QUICHE_CHECK(destination_.FromString(kDestinationAddress));
 
     int pipe_fds[2];
-    CHECK(pipe(pipe_fds) >= 0) << "pipe() failed";
+    QUICHE_CHECK(pipe(pipe_fds) >= 0) << "pipe() failed";
 
     read_fd_ = pipe_fds[0];
     read_src_fd_ = pipe_fds[1];
diff --git a/quic/qbone/platform/netlink_test.cc b/quic/qbone/platform/netlink_test.cc
index adb329c..084532f 100644
--- a/quic/qbone/platform/netlink_test.cc
+++ b/quic/qbone/platform/netlink_test.cc
@@ -74,7 +74,7 @@
             send_callback(buf.c_str(), buf.size());
           }
 
-          CHECK_EQ(seq, -1);
+          QUICHE_CHECK_EQ(seq, -1);
           seq = netlink_message->nlmsg_seq;
           return buf.size();
         }));
@@ -90,7 +90,7 @@
           nl_addr->nl_groups = 0;  // no multicast
 
           int ret = recv_callback(reply_packet_, sizeof(reply_packet_), seq);
-          CHECK_LE(ret, sizeof(reply_packet_));
+          QUICHE_CHECK_LE(ret, sizeof(reply_packet_));
           return ret;
         }));
 
@@ -185,7 +185,7 @@
                      unsigned char flags,
                      unsigned char scope,
                      QuicIpAddress ip) {
-  CHECK(ip.IsInitialized());
+  QUICHE_CHECK(ip.IsInitialized());
   unsigned char family;
   switch (ip.address_family()) {
     case IpAddressFamily::IP_V4:
diff --git a/quic/qbone/platform/rtnetlink_message_test.cc b/quic/qbone/platform/rtnetlink_message_test.cc
index 00b0caa..f2d9d92 100644
--- a/quic/qbone/platform/rtnetlink_message_test.cc
+++ b/quic/qbone/platform/rtnetlink_message_test.cc
@@ -124,7 +124,7 @@
                                      seq, pid, &interface_address_header);
 
   QuicIpAddress ip;
-  CHECK(ip.FromString("10.0.100.3"));
+  QUICHE_CHECK(ip.FromString("10.0.100.3"));
   message.AppendAttribute(IFA_ADDRESS, ip.ToPackedString().c_str(),
                           ip.ToPackedString().size());
 
@@ -181,7 +181,7 @@
                                    pid, &route_message_header);
 
   QuicIpAddress preferred_source;
-  CHECK(preferred_source.FromString("ff80::1"));
+  QUICHE_CHECK(preferred_source.FromString("ff80::1"));
   message.AppendAttribute(RTA_PREFSRC,
                           preferred_source.ToPackedString().c_str(),
                           preferred_source.ToPackedString().size());
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index c2f3ef3..f3b6290 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -42,7 +42,8 @@
       ->CryptoConnect();
   // Register the reserved control stream.
   QuicStreamId next_id = GetNextOutgoingBidirectionalStreamId();
-  DCHECK_EQ(next_id, QboneConstants::GetControlStreamId(transport_version()));
+  QUICHE_DCHECK_EQ(next_id,
+                   QboneConstants::GetControlStreamId(transport_version()));
   auto control_stream =
       std::make_unique<QboneClientControlStream>(this, handler_);
   control_stream_ = control_stream.get();
diff --git a/quic/qbone/qbone_client_test.cc b/quic/qbone/qbone_client_test.cc
index 28d7bbc..75a3a1e 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -128,7 +128,7 @@
       const QuicSocketAddress& peer_address,
       absl::string_view alpn,
       const quic::ParsedQuicVersion& version) override {
-    CHECK_EQ(alpn, "qbone");
+    QUICHE_CHECK_EQ(alpn, "qbone");
     QuicConnection* connection = new QuicConnection(
         id, self_address, peer_address, helper(), alarm_factory(), writer(),
         /* owns_writer= */ false, Perspective::IS_SERVER,
diff --git a/quic/qbone/qbone_packet_processor.cc b/quic/qbone/qbone_packet_processor.cc
index 8f908db..c993557 100644
--- a/quic/qbone/qbone_packet_processor.cc
+++ b/quic/qbone/qbone_packet_processor.cc
@@ -38,12 +38,12 @@
       stats_(stats),
       filter_(new Filter) {
   memcpy(self_ip_.s6_addr, self_ip.ToPackedString().data(), kIPv6AddressSize);
-  DCHECK_LE(client_ip_subnet_length, kIPv6AddressSize * 8);
+  QUICHE_DCHECK_LE(client_ip_subnet_length, kIPv6AddressSize * 8);
   client_ip_subnet_length_ = client_ip_subnet_length;
 
-  DCHECK(IpAddressFamily::IP_V6 == self_ip.address_family());
-  DCHECK(IpAddressFamily::IP_V6 == client_ip.address_family());
-  DCHECK(self_ip != kInvalidIpAddress);
+  QUICHE_DCHECK(IpAddressFamily::IP_V6 == self_ip.address_family());
+  QUICHE_DCHECK(IpAddressFamily::IP_V6 == client_ip.address_family());
+  QUICHE_DCHECK(self_ip != kInvalidIpAddress);
 }
 
 QbonePacketProcessor::OutputInterface::~OutputInterface() {}
@@ -201,7 +201,7 @@
       address_reject_code = ICMP6_DST_UNREACH_NOROUTE;
       break;
   }
-  DCHECK(ip_parse_result);
+  QUICHE_DCHECK(ip_parse_result);
   if (!client_ip_.InSameSubnet(address_to_check, client_ip_subnet_length_)) {
     QUIC_DVLOG(1)
         << "Dropped packet: source/destination address is not client's";
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index df88a8e..d79400c 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -138,9 +138,9 @@
 class QbonePacketProcessorTest : public QuicTest {
  protected:
   QbonePacketProcessorTest() {
-    CHECK(client_ip_.FromString("fd00:0:0:1::1"));
-    CHECK(self_ip_.FromString("fd00:0:0:4::1"));
-    CHECK(network_ip_.FromString("fd00:0:0:5::1"));
+    QUICHE_CHECK(client_ip_.FromString("fd00:0:0:1::1"));
+    QUICHE_CHECK(self_ip_.FromString("fd00:0:0:4::1"));
+    QUICHE_CHECK(network_ip_.FromString("fd00:0:0:5::1"));
 
     processor_ = std::make_unique<QbonePacketProcessor>(
         self_ip_, client_ip_, /*client_ip_subnet_length=*/62, &output_,
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 036c8ac..76a460c 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -89,7 +89,7 @@
 }
 
 void QboneServerSession::SendPacketToNetwork(absl::string_view packet) {
-  DCHECK(writer_ != nullptr);
+  QUICHE_DCHECK(writer_ != nullptr);
   writer_->WritePacketToNetwork(packet.data(), packet.size());
 }
 
diff --git a/quic/quic_transport/quic_transport_stream.cc b/quic/quic_transport/quic_transport_stream.cc
index 91b644d..e27f469 100644
--- a/quic/quic_transport/quic_transport_stream.cc
+++ b/quic/quic_transport/quic_transport_stream.cc
@@ -47,7 +47,7 @@
   const size_t bytes_to_read = ReadableBytes();
   output->resize(old_size + bytes_to_read);
   size_t bytes_read = Read(&(*output)[old_size], bytes_to_read);
-  DCHECK_EQ(bytes_to_read, bytes_read);
+  QUICHE_DCHECK_EQ(bytes_to_read, bytes_read);
   output->resize(old_size + bytes_read);
   return bytes_read;
 }
@@ -93,7 +93,7 @@
   QuicMemSlice empty;
   QuicConsumedData consumed =
       WriteMemSlices(QuicMemSliceSpan(&empty), /*fin=*/true);
-  DCHECK_EQ(consumed.bytes_consumed, 0u);
+  QUICHE_DCHECK_EQ(consumed.bytes_consumed, 0u);
   return consumed.fin_consumed;
 }
 
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index ce1c217..23f24d6 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -263,7 +263,7 @@
       });
 
   // The client's handshake must have been started already.
-  CHECK_NE(0u, client_conn->encrypted_packets_.size());
+  QUICHE_CHECK_NE(0u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn,
                                server_session.GetMutableCryptoStream());
@@ -292,7 +292,7 @@
                          return version.handshake_protocol != PROTOCOL_TLS1_3;
                        }),
         supported_versions.end());
-    CHECK(!options.only_quic_crypto_versions);
+    QUICHE_CHECK(!options.only_quic_crypto_versions);
   } else if (options.only_quic_crypto_versions) {
     supported_versions.erase(
         std::remove_if(supported_versions.begin(), supported_versions.end(),
@@ -326,7 +326,7 @@
             {AlpnForVersion(client_conn->version())})));
   }
   client_session.GetMutableCryptoStream()->CryptoConnect();
-  CHECK_EQ(1u, client_conn->encrypted_packets_.size());
+  QUICHE_CHECK_EQ(1u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessages(client_conn,
                                client_session.GetMutableCryptoStream(),
@@ -459,7 +459,7 @@
       AllSupportedVersionsWithQuicCrypto().front().transport_version, "",
       std::unique_ptr<ProofSource::Callback>(new Callback(&ok, &chain)));
   if (!ok || chain->certs.empty()) {
-    DCHECK(false) << "Proof generation failed";
+    QUICHE_DCHECK(false) << "Proof generation failed";
     return 0;
   }
 
@@ -655,26 +655,26 @@
 
 QuicTag ParseTag(const char* tagstr) {
   const size_t len = strlen(tagstr);
-  CHECK_NE(0u, len);
+  QUICHE_CHECK_NE(0u, len);
 
   QuicTag tag = 0;
 
   if (tagstr[0] == '#') {
-    CHECK_EQ(static_cast<size_t>(1 + 2 * 4), len);
+    QUICHE_CHECK_EQ(static_cast<size_t>(1 + 2 * 4), len);
     tagstr++;
 
     for (size_t i = 0; i < 8; i++) {
       tag <<= 4;
 
       uint8_t v = 0;
-      CHECK(HexChar(tagstr[i], &v));
+      QUICHE_CHECK(HexChar(tagstr[i], &v));
       tag |= v;
     }
 
     return tag;
   }
 
-  CHECK_LE(len, 4u);
+  QUICHE_CHECK_LE(len, 4u);
   for (size_t i = 0; i < 4; i++) {
     tag >>= 8;
     if (i < len) {
@@ -723,7 +723,7 @@
       CryptoFramer::ConstructHandshakeMessage(msg);
   std::unique_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
-  CHECK(parsed);
+  QUICHE_CHECK(parsed);
 
   return *parsed;
 }
@@ -840,7 +840,7 @@
   std::unique_ptr<CryptoHandshakeMessage> msg =
       crypto_config->AddConfig(primary_config, clock->WallNow());
   absl::string_view orbit;
-  CHECK(msg->GetStringPiece(kORBT, &orbit));
+  QUICHE_CHECK(msg->GetStringPiece(kORBT, &orbit));
   std::string nonce;
   CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
                              &nonce);
diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 0d3da93..bc75678 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -140,7 +140,7 @@
 }
 
 void FakeProofSource::InvokePendingCallback(int n) {
-  CHECK(NumPendingCallbacks() > n);
+  QUICHE_CHECK(NumPendingCallbacks() > n);
 
   pending_ops_[n]->Run();
 
diff --git a/quic/test_tools/fake_proof_source_handle.cc b/quic/test_tools/fake_proof_source_handle.cc
index 437a913..673d957 100644
--- a/quic/test_tools/fake_proof_source_handle.cc
+++ b/quic/test_tools/fake_proof_source_handle.cc
@@ -22,7 +22,7 @@
   explicit ResultSavingSignatureCallback(
       absl::optional<ComputeSignatureResult>* result)
       : result_(result) {
-    DCHECK(!result_->has_value());
+    QUICHE_DCHECK(!result_->has_value());
   }
   void Run(bool ok,
            std::string signature,
@@ -46,8 +46,9 @@
   delegate->ComputeTlsSignature(
       server_address, client_address, hostname, signature_algorithm, in,
       std::make_unique<ResultSavingSignatureCallback>(&result));
-  CHECK(result.has_value()) << "delegate->ComputeTlsSignature must computes a "
-                               "signature immediately";
+  QUICHE_CHECK(result.has_value())
+      << "delegate->ComputeTlsSignature must computes a "
+         "signature immediately";
   return std::move(result.value());
 }
 }  // namespace
@@ -88,7 +89,7 @@
     return QUIC_FAILURE;
   }
 
-  DCHECK(select_cert_action_ == Action::DELEGATE_SYNC);
+  QUICHE_DCHECK(select_cert_action_ == Action::DELEGATE_SYNC);
   QuicReferenceCountedPointer<ProofSource::Chain> chain =
       delegate_->GetCertChain(server_address, client_address, hostname);
 
@@ -116,7 +117,7 @@
     return QUIC_FAILURE;
   }
 
-  DCHECK(compute_signature_action_ == Action::DELEGATE_SYNC);
+  QUICHE_DCHECK(compute_signature_action_ == Action::DELEGATE_SYNC);
   ComputeSignatureResult result =
       ComputeSignatureNow(delegate_, server_address, client_address, hostname,
                           signature_algorithm, in);
@@ -135,7 +136,7 @@
 }
 
 void FakeProofSourceHandle::CompletePendingOperation() {
-  DCHECK_LE(NumPendingOperations(), 1);
+  QUICHE_DCHECK_LE(NumPendingOperations(), 1);
 
   if (select_cert_op_.has_value()) {
     select_cert_op_->Run();
diff --git a/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc b/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
index e3a9bdf..0126d4b 100644
--- a/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
+++ b/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
@@ -222,7 +222,7 @@
     uint16_t payload_size = data_provider.ConsumeIntegralInRange<uint16_t>(
         min_payload_size, max_payload_size);
 
-    CHECK_NE(last_remaining_bytes, data_provider.remaining_bytes())
+    QUICHE_CHECK_NE(last_remaining_bytes, data_provider.remaining_bytes())
         << "Check fail to avoid an infinite loop. ConsumeIntegralInRange("
         << min_payload_size << ", " << max_payload_size
         << ") did not consume any bytes. remaining_bytes:"
@@ -230,28 +230,30 @@
 
     std::vector<char> payload_buffer =
         data_provider.ConsumeBytes<char>(payload_size);
-    CHECK_GE(packet_buffer.size(),
-             GetPacketHeaderSize(sender_framer.transport_version(), header) +
-                 payload_buffer.size());
+    QUICHE_CHECK_GE(
+        packet_buffer.size(),
+        GetPacketHeaderSize(sender_framer.transport_version(), header) +
+            payload_buffer.size());
 
     // Serialize the null-encrypted packet into |packet_buffer|.
     QuicDataWriter writer(packet_buffer.size(), packet_buffer.data());
     size_t length_field_offset = 0;
-    CHECK(sender_framer.AppendPacketHeader(header, &writer,
-                                           &length_field_offset));
+    QUICHE_CHECK(sender_framer.AppendPacketHeader(header, &writer,
+                                                  &length_field_offset));
 
-    CHECK(writer.WriteBytes(payload_buffer.data(), payload_buffer.size()));
+    QUICHE_CHECK(
+        writer.WriteBytes(payload_buffer.data(), payload_buffer.size()));
 
     EncryptionLevel encryption_level =
         quic::test::HeaderToEncryptionLevel(header);
-    CHECK(sender_framer.WriteIetfLongHeaderLength(
+    QUICHE_CHECK(sender_framer.WriteIetfLongHeaderLength(
         header, &writer, length_field_offset, encryption_level));
 
     size_t encrypted_length = sender_framer.EncryptInPlace(
         encryption_level, header.packet_number,
         GetStartOfEncryptedData(sender_framer.transport_version(), header),
         writer.length(), packet_buffer.size(), packet_buffer.data());
-    CHECK_NE(encrypted_length, 0u);
+    QUICHE_CHECK_NE(encrypted_length, 0u);
 
     // Use receiver's framer to process the packet. Ensure both
     // ProcessPublicHeader and DecryptPayload were called and succeeded.
@@ -265,14 +267,15 @@
 
     receiver_framer.ProcessPacket(packet);
 
-    DCHECK_EQ(process_public_header_success_count + 1,
-              receiver_framer_visitor.process_public_header_success_count_)
+    QUICHE_DCHECK_EQ(
+        process_public_header_success_count + 1,
+        receiver_framer_visitor.process_public_header_success_count_)
         << "ProcessPublicHeader failed. error:"
         << QuicErrorCodeToString(receiver_framer.error())
         << ", error_detail:" << receiver_framer.detailed_error()
         << ". header:" << header;
-    DCHECK_EQ(decrypted_packet_count + 1,
-              receiver_framer_visitor.decrypted_packet_count_)
+    QUICHE_DCHECK_EQ(decrypted_packet_count + 1,
+                     receiver_framer_visitor.decrypted_packet_count_)
         << "Packet was not decrypted. error:"
         << QuicErrorCodeToString(receiver_framer.error())
         << ", error_detail:" << receiver_framer.detailed_error()
diff --git a/quic/test_tools/packet_dropping_test_writer.cc b/quic/test_tools/packet_dropping_test_writer.cc
index bf763ef..35cc978 100644
--- a/quic/test_tools/packet_dropping_test_writer.cc
+++ b/quic/test_tools/packet_dropping_test_writer.cc
@@ -118,7 +118,7 @@
   if (fake_blocked_socket_percentage_ > 0 &&
       simple_random_.RandUint64() % 100 <
           static_cast<uint64_t>(fake_blocked_socket_percentage_)) {
-    CHECK(on_can_write_ != nullptr);
+    QUICHE_CHECK(on_can_write_ != nullptr);
     QUIC_DVLOG(1) << "Blocking socket for packet " << num_calls_to_write_;
     if (!write_unblocked_alarm_->IsSet()) {
       // Set the alarm to fire immediately.
@@ -206,7 +206,7 @@
   QuicPacketWriterWrapper::WritePacket(
       iter->buffer.data(), iter->buffer.length(), iter->self_address,
       iter->peer_address, iter->options.get());
-  DCHECK_GE(cur_buffer_size_, iter->buffer.length());
+  QUICHE_DCHECK_GE(cur_buffer_size_, iter->buffer.length());
   cur_buffer_size_ -= iter->buffer.length();
   delayed_packets_.erase(iter);
 
diff --git a/quic/test_tools/packet_reordering_writer.cc b/quic/test_tools/packet_reordering_writer.cc
index 2fb5f7e..1b931eb 100644
--- a/quic/test_tools/packet_reordering_writer.cc
+++ b/quic/test_tools/packet_reordering_writer.cc
@@ -32,7 +32,8 @@
     return wr;
   }
   // Still have packet to wait.
-  DCHECK_LT(0u, num_packets_to_wait_) << "Only allow one packet to be delayed";
+  QUICHE_DCHECK_LT(0u, num_packets_to_wait_)
+      << "Only allow one packet to be delayed";
   delayed_data_ = std::string(buffer, buf_len);
   delayed_self_address_ = self_address;
   delayed_peer_address_ = peer_address;
@@ -44,7 +45,7 @@
 }
 
 void PacketReorderingWriter::SetDelay(size_t num_packets_to_wait) {
-  DCHECK_GT(num_packets_to_wait, 0u);
+  QUICHE_DCHECK_GT(num_packets_to_wait, 0u);
   num_packets_to_wait_ = num_packets_to_wait;
   delay_next_ = true;
 }
diff --git a/quic/test_tools/qpack/qpack_decoder_test_utils.cc b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
index bc1a60b..ab76c44 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.cc
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
@@ -46,8 +46,8 @@
 }
 
 spdy::Http2HeaderBlock TestHeadersHandler::ReleaseHeaderList() {
-  DCHECK(decoding_completed_);
-  DCHECK(!decoding_error_detected_);
+  QUICHE_DCHECK(decoding_completed_);
+  QUICHE_DCHECK(!decoding_error_detected_);
 
   return std::move(header_list_);
 }
@@ -61,7 +61,7 @@
 }
 
 const std::string& TestHeadersHandler::error_message() const {
-  DCHECK(decoding_error_detected_);
+  QUICHE_DCHECK(decoding_error_detected_);
   return error_message_;
 }
 
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.cc b/quic/test_tools/qpack/qpack_offline_decoder.cc
index 025c1ed..6bad8d6 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.cc
+++ b/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -218,7 +218,7 @@
   }
 
   if (!decoders_.empty()) {
-    DCHECK(!decoders_.front().headers_handler->decoding_completed());
+    QUICHE_DCHECK(!decoders_.front().headers_handler->decoding_completed());
 
     QUIC_LOG(ERROR) << "Blocked decoding uncomplete after reading entire"
                        " file, on stream "
diff --git a/quic/test_tools/quic_config_peer.cc b/quic/test_tools/quic_config_peer.cc
index 928f842..9bd5dd3 100644
--- a/quic/test_tools/quic_config_peer.cc
+++ b/quic/test_tools/quic_config_peer.cc
@@ -60,7 +60,7 @@
 // static
 void QuicConfigPeer::SetReceivedBytesForConnectionId(QuicConfig* config,
                                                      uint32_t bytes) {
-  DCHECK(bytes == 0 || bytes == 8);
+  QUICHE_DCHECK(bytes == 0 || bytes == 8);
   config->bytes_for_connection_id_.SetReceivedValue(bytes);
 }
 
diff --git a/quic/test_tools/quic_packet_creator_peer.cc b/quic/test_tools/quic_packet_creator_peer.cc
index 7098fb2..0caf263 100644
--- a/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quic/test_tools/quic_packet_creator_peer.cc
@@ -30,7 +30,7 @@
     creator->packet_.encryption_level = ENCRYPTION_FORWARD_SECURE;
     return;
   }
-  DCHECK(creator->packet_.encryption_level < ENCRYPTION_FORWARD_SECURE);
+  QUICHE_DCHECK(creator->packet_.encryption_level < ENCRYPTION_FORWARD_SECURE);
 }
 
 // static
@@ -60,7 +60,7 @@
 
 void QuicPacketCreatorPeer::SetPacketNumber(QuicPacketCreator* creator,
                                             uint64_t s) {
-  DCHECK_NE(0u, s);
+  QUICHE_DCHECK_NE(0u, s);
   creator->packet_.packet_number = QuicPacketNumber(s);
 }
 
@@ -105,15 +105,15 @@
     const QuicFrames& frames,
     char* buffer,
     size_t buffer_len) {
-  DCHECK(creator->queued_frames_.empty());
-  DCHECK(!frames.empty());
+  QUICHE_DCHECK(creator->queued_frames_.empty());
+  QUICHE_DCHECK(!frames.empty());
   for (const QuicFrame& frame : frames) {
     bool success = creator->AddFrame(frame, NOT_RETRANSMISSION);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   }
   const bool success = creator->SerializePacket(
       QuicOwnedPacketBuffer(buffer, nullptr), buffer_len);
-  DCHECK(success);
+  QUICHE_DCHECK(success);
   SerializedPacket packet = std::move(creator->packet_);
   // The caller takes ownership of the QuicEncryptedPacket.
   creator->packet_.encrypted_buffer = nullptr;
diff --git a/quic/test_tools/quic_sent_packet_manager_peer.cc b/quic/test_tools/quic_sent_packet_manager_peer.cc
index f358783..0789946 100644
--- a/quic/test_tools/quic_sent_packet_manager_peer.cc
+++ b/quic/test_tools/quic_sent_packet_manager_peer.cc
@@ -82,7 +82,7 @@
 bool QuicSentPacketManagerPeer::IsRetransmission(
     QuicSentPacketManager* sent_packet_manager,
     uint64_t packet_number) {
-  DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
+  QUICHE_DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
   if (!HasRetransmittableFrames(sent_packet_manager, packet_number)) {
     return false;
   }
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 49466b5..344b1b1 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -53,7 +53,7 @@
 void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
          "QUIC";
   session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
@@ -63,7 +63,7 @@
 void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
          "QUIC";
   session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
@@ -84,7 +84,7 @@
 void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
          "QUIC";
   session->ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
@@ -94,7 +94,7 @@
 void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
          "QUIC";
   session->ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index acb66df..58eedcc 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -15,13 +15,13 @@
 // static
 QuicHeadersStream* QuicSpdySessionPeer::GetHeadersStream(
     QuicSpdySession* session) {
-  DCHECK(!VersionUsesHttp3(session->transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(session->transport_version()));
   return session->headers_stream();
 }
 
 void QuicSpdySessionPeer::SetHeadersStream(QuicSpdySession* session,
                                            QuicHeadersStream* headers_stream) {
-  DCHECK(!VersionUsesHttp3(session->transport_version()));
+  QUICHE_DCHECK(!VersionUsesHttp3(session->transport_version()));
   for (auto& it : QuicSessionPeer::stream_map(session)) {
     if (it.first ==
         QuicUtils::GetHeadersStreamId(session->transport_version())) {
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index 9dcfb42..4133950 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -164,12 +164,12 @@
   }
 
   void UseWriter(QuicPacketWriterWrapper* writer) {
-    CHECK(test_writer_ == nullptr);
+    QUICHE_CHECK(test_writer_ == nullptr);
     test_writer_ = writer;
   }
 
   void set_peer_address(const QuicSocketAddress& address) {
-    CHECK(test_writer_ != nullptr);
+    QUICHE_CHECK(test_writer_ != nullptr);
     test_writer_->set_peer_address(address);
   }
 
@@ -834,24 +834,24 @@
 }
 
 void QuicTestClient::UseConnectionId(QuicConnectionId server_connection_id) {
-  DCHECK(!connected());
+  QUICHE_DCHECK(!connected());
   client_->UseConnectionId(server_connection_id);
 }
 
 void QuicTestClient::UseConnectionIdLength(int server_connection_id_length) {
-  DCHECK(!connected());
+  QUICHE_DCHECK(!connected());
   client_->UseConnectionIdLength(server_connection_id_length);
 }
 
 void QuicTestClient::UseClientConnectionId(
     QuicConnectionId client_connection_id) {
-  DCHECK(!connected());
+  QUICHE_DCHECK(!connected());
   client_->UseClientConnectionId(client_connection_id);
 }
 
 void QuicTestClient::UseClientConnectionIdLength(
     int client_connection_id_length) {
-  DCHECK(!connected());
+  QUICHE_DCHECK(!connected());
   client_->UseClientConnectionIdLength(client_connection_id_length);
 }
 
diff --git a/quic/test_tools/quic_test_server.cc b/quic/test_tools/quic_test_server.cc
index 59fac5d..55170b2 100644
--- a/quic/test_tools/quic_test_server.cc
+++ b/quic/test_tools/quic_test_server.cc
@@ -127,23 +127,23 @@
 
   void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
     QuicWriterMutexLock lock(&factory_lock_);
-    DCHECK(session_factory_ == nullptr);
-    DCHECK(stream_factory_ == nullptr);
-    DCHECK(crypto_stream_factory_ == nullptr);
+    QUICHE_DCHECK(session_factory_ == nullptr);
+    QUICHE_DCHECK(stream_factory_ == nullptr);
+    QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
     session_factory_ = factory;
   }
 
   void SetStreamFactory(QuicTestServer::StreamFactory* factory) {
     QuicWriterMutexLock lock(&factory_lock_);
-    DCHECK(session_factory_ == nullptr);
-    DCHECK(stream_factory_ == nullptr);
+    QUICHE_DCHECK(session_factory_ == nullptr);
+    QUICHE_DCHECK(stream_factory_ == nullptr);
     stream_factory_ = factory;
   }
 
   void SetCryptoStreamFactory(QuicTestServer::CryptoStreamFactory* factory) {
     QuicWriterMutexLock lock(&factory_lock_);
-    DCHECK(session_factory_ == nullptr);
-    DCHECK(crypto_stream_factory_ == nullptr);
+    QUICHE_DCHECK(session_factory_ == nullptr);
+    QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
     crypto_stream_factory_ = factory;
   }
 
@@ -195,7 +195,7 @@
 }
 
 void QuicTestServer::SetSessionFactory(SessionFactory* factory) {
-  DCHECK(dispatcher());
+  QUICHE_DCHECK(dispatcher());
   static_cast<QuicTestDispatcher*>(dispatcher())->SetSessionFactory(factory);
 }
 
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index a2aa11c..fb5d772 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -71,7 +71,7 @@
 }
 
 uint64_t TestConnectionIdToUInt64(QuicConnectionId connection_id) {
-  DCHECK_EQ(connection_id.length(), kQuicDefaultConnectionIdLength);
+  QUICHE_DCHECK_EQ(connection_id.length(), kQuicDefaultConnectionIdLength);
   uint64_t connection_id64_net = 0;
   memcpy(&connection_id64_net, connection_id.data(),
          std::min<size_t>(static_cast<size_t>(connection_id.length()),
@@ -97,13 +97,13 @@
 }
 
 QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks) {
-  DCHECK_GT(ack_blocks.size(), 0u);
+  QUICHE_DCHECK_GT(ack_blocks.size(), 0u);
 
   QuicAckFrame ack;
   QuicPacketNumber end_of_previous_block(1);
   for (const QuicAckBlock& block : ack_blocks) {
-    DCHECK_GE(block.start, end_of_previous_block);
-    DCHECK_GT(block.limit, block.start);
+    QUICHE_DCHECK_GE(block.start, end_of_previous_block);
+    QUICHE_DCHECK_GT(block.limit, block.start);
     ack.packets.AddRange(block.start, block.limit);
     end_of_previous_block = block.limit;
   }
@@ -170,13 +170,13 @@
       framer->GetMaxPlaintextSize(kMaxOutgoingPacketSize);
   size_t packet_size = GetPacketHeaderSize(framer->transport_version(), header);
   for (size_t i = 0; i < frames.size(); ++i) {
-    DCHECK_LE(packet_size, max_plaintext_size);
+    QUICHE_DCHECK_LE(packet_size, max_plaintext_size);
     bool first_frame = i == 0;
     bool last_frame = i == frames.size() - 1;
     const size_t frame_size = framer->GetSerializedFrameLength(
         frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
         header.packet_number_length);
-    DCHECK(frame_size);
+    QUICHE_DCHECK(frame_size);
     packet_size += frame_size;
   }
   return BuildUnsizedDataPacket(framer, header, frames, packet_size);
@@ -191,7 +191,7 @@
   EncryptionLevel level = HeaderToEncryptionLevel(header);
   size_t length =
       framer->BuildDataPacket(header, frames, buffer, packet_size, level);
-  DCHECK_NE(0u, length);
+  QUICHE_DCHECK_NE(0u, length);
   // Re-construct the data packet with data ownership.
   return std::make_unique<QuicPacket>(
       buffer, length, /* owns_buffer */ true,
@@ -638,11 +638,11 @@
   if (write_length > 0) {
     auto buf = std::make_unique<char[]>(write_length);
     QuicStream* stream = GetOrCreateStream(id);
-    DCHECK(stream);
+    QUICHE_DCHECK(stream);
     QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
     stream->WriteStreamData(offset, write_length, &writer);
   } else {
-    DCHECK(state != NO_FIN);
+    QUICHE_DCHECK(state != NO_FIN);
   }
   return QuicConsumedData(write_length, state != NO_FIN);
 }
@@ -727,11 +727,11 @@
   if (write_length > 0) {
     auto buf = std::make_unique<char[]>(write_length);
     QuicStream* stream = GetOrCreateStream(id);
-    DCHECK(stream);
+    QUICHE_DCHECK(stream);
     QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
     stream->WriteStreamData(offset, write_length, &writer);
   } else {
-    DCHECK(state != NO_FIN);
+    QUICHE_DCHECK(state != NO_FIN);
   }
   return QuicConsumedData(write_length, state != NO_FIN);
 }
@@ -1208,10 +1208,10 @@
     QuicCryptoClientConfig* crypto_client_config,
     PacketSavingConnection** client_connection,
     TestQuicSpdyClientSession** client_session) {
-  CHECK(crypto_client_config);
-  CHECK(client_connection);
-  CHECK(client_session);
-  CHECK(!connection_start_time.IsZero())
+  QUICHE_CHECK(crypto_client_config);
+  QUICHE_CHECK(client_connection);
+  QUICHE_CHECK(client_session);
+  QUICHE_CHECK(!connection_start_time.IsZero())
       << "Connections must start at non-zero times, otherwise the "
       << "strike-register will be unhappy.";
 
@@ -1234,10 +1234,10 @@
     QuicCompressedCertsCache* compressed_certs_cache,
     PacketSavingConnection** server_connection,
     TestQuicSpdyServerSession** server_session) {
-  CHECK(server_crypto_config);
-  CHECK(server_connection);
-  CHECK(server_session);
-  CHECK(!connection_start_time.IsZero())
+  QUICHE_CHECK(server_crypto_config);
+  QUICHE_CHECK(server_connection);
+  QUICHE_CHECK(server_session);
+  QUICHE_CHECK(!connection_start_time.IsZero())
       << "Connections must start at non-zero times, otherwise the "
       << "strike-register will be unhappy.";
 
diff --git a/quic/test_tools/server_thread.cc b/quic/test_tools/server_thread.cc
index a744ac6..f5c9b7e 100644
--- a/quic/test_tools/server_thread.cc
+++ b/quic/test_tools/server_thread.cc
@@ -61,7 +61,7 @@
 }
 
 void ServerThread::Schedule(std::function<void()> action) {
-  DCHECK(!quit_.HasBeenNotified());
+  QUICHE_DCHECK(!quit_.HasBeenNotified());
   QuicWriterMutexLock lock(&scheduled_actions_lock_);
   scheduled_actions_.push_back(std::move(action));
 }
@@ -89,14 +89,14 @@
 }
 
 void ServerThread::Pause() {
-  DCHECK(!pause_.HasBeenNotified());
+  QUICHE_DCHECK(!pause_.HasBeenNotified());
   pause_.Notify();
   paused_.WaitForNotification();
 }
 
 void ServerThread::Resume() {
-  DCHECK(!resume_.HasBeenNotified());
-  DCHECK(pause_.HasBeenNotified());
+  QUICHE_DCHECK(!resume_.HasBeenNotified());
+  QUICHE_DCHECK(pause_.HasBeenNotified());
   resume_.Notify();
 }
 
diff --git a/quic/test_tools/simple_quic_framer.cc b/quic/test_tools/simple_quic_framer.cc
index 04d44b1..96b1318 100644
--- a/quic/test_tools/simple_quic_framer.cc
+++ b/quic/test_tools/simple_quic_framer.cc
@@ -101,7 +101,7 @@
   }
 
   bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override {
-    DCHECK(!ack_frames_.empty());
+    QUICHE_DCHECK(!ack_frames_.empty());
     ack_frames_[ack_frames_.size() - 1].packets.AddRange(start, end);
     return true;
   }
diff --git a/quic/test_tools/simple_session_notifier.cc b/quic/test_tools/simple_session_notifier.cc
index 1a75a4c..415332a 100644
--- a/quic/test_tools/simple_session_notifier.cc
+++ b/quic/test_tools/simple_session_notifier.cc
@@ -481,7 +481,7 @@
   if (id == kInvalidControlFrameId) {
     return false;
   }
-  DCHECK(id < least_unacked_ + control_frames_.size());
+  QUICHE_DCHECK(id < least_unacked_ + control_frames_.size());
   if (id < least_unacked_ ||
       GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
           kInvalidControlFrameId) {
@@ -504,7 +504,7 @@
   if (id == kInvalidControlFrameId) {
     return;
   }
-  DCHECK(id < least_unacked_ + control_frames_.size());
+  QUICHE_DCHECK(id < least_unacked_ + control_frames_.size());
   if (id < least_unacked_ ||
       GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
           kInvalidControlFrameId) {
diff --git a/quic/test_tools/simulator/alarm_factory.cc b/quic/test_tools/simulator/alarm_factory.cc
index 8ea3e58..4e1ed2e 100644
--- a/quic/test_tools/simulator/alarm_factory.cc
+++ b/quic/test_tools/simulator/alarm_factory.cc
@@ -21,7 +21,7 @@
   ~Alarm() override {}
 
   void SetImpl() override {
-    DCHECK(deadline().IsInitialized());
+    QUICHE_DCHECK(deadline().IsInitialized());
     adapter_.Set(deadline());
   }
 
@@ -41,7 +41,7 @@
     void Cancel() { Unschedule(); }
 
     void Act() override {
-      DCHECK(clock_->Now() >= parent_->deadline());
+      QUICHE_DCHECK(clock_->Now() >= parent_->deadline());
       parent_->Fire();
     }
 
diff --git a/quic/test_tools/simulator/link.cc b/quic/test_tools/simulator/link.cc
index dcfd2dc..16850a9 100644
--- a/quic/test_tools/simulator/link.cc
+++ b/quic/test_tools/simulator/link.cc
@@ -35,7 +35,7 @@
 OneWayLink::QueuedPacket::~QueuedPacket() {}
 
 void OneWayLink::AcceptPacket(std::unique_ptr<Packet> packet) {
-  DCHECK(TimeUntilAvailable().IsZero());
+  QUICHE_DCHECK(TimeUntilAvailable().IsZero());
   QuicTime::Delta transfer_time = bandwidth_.TransferTime(packet->size);
   next_write_at_ = clock_->Now() + transfer_time;
 
@@ -60,8 +60,8 @@
 }
 
 void OneWayLink::Act() {
-  DCHECK(!packets_in_transit_.empty());
-  DCHECK(packets_in_transit_.front().dequeue_time >= clock_->Now());
+  QUICHE_DCHECK(!packets_in_transit_.empty());
+  QUICHE_DCHECK(packets_in_transit_.front().dequeue_time >= clock_->Now());
 
   sink_->AcceptPacket(std::move(packets_in_transit_.front().packet));
   packets_in_transit_.pop_front();
diff --git a/quic/test_tools/simulator/queue.cc b/quic/test_tools/simulator/queue.cc
index fc0c320..5113cf7 100644
--- a/quic/test_tools/simulator/queue.cc
+++ b/quic/test_tools/simulator/queue.cc
@@ -59,9 +59,9 @@
 }
 
 void Queue::Act() {
-  DCHECK(!queue_.empty());
+  QUICHE_DCHECK(!queue_.empty());
   if (tx_port_->TimeUntilAvailable().IsZero()) {
-    DCHECK(bytes_queued_ >= queue_.front().packet->size);
+    QUICHE_DCHECK(bytes_queued_ >= queue_.front().packet->size);
     bytes_queued_ -= queue_.front().packet->size;
 
     tx_port_->AcceptPacket(std::move(queue_.front().packet));
@@ -76,10 +76,10 @@
 
 void Queue::EnableAggregation(QuicByteCount aggregation_threshold,
                               QuicTime::Delta aggregation_timeout) {
-  DCHECK_EQ(bytes_queued_, 0u);
-  DCHECK_GT(aggregation_threshold, 0u);
-  DCHECK(!aggregation_timeout.IsZero());
-  DCHECK(!aggregation_timeout.IsInfinite());
+  QUICHE_DCHECK_EQ(bytes_queued_, 0u);
+  QUICHE_DCHECK_GT(aggregation_threshold, 0u);
+  QUICHE_DCHECK(!aggregation_timeout.IsZero());
+  QUICHE_DCHECK(!aggregation_timeout.IsInfinite());
 
   aggregation_threshold_ = aggregation_threshold;
   aggregation_timeout_ = aggregation_timeout;
@@ -109,7 +109,7 @@
 
 void Queue::ScheduleNextPacketDequeue() {
   if (queue_.empty()) {
-    DCHECK_EQ(bytes_queued_, 0u);
+    QUICHE_DCHECK_EQ(bytes_queued_, 0u);
     return;
   }
 
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index 2534b8d..cb0b58e 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -74,7 +74,8 @@
   QuicErrorCode error_code = config.ProcessPeerHello(
       peer_hello, perspective == Perspective::IS_CLIENT ? SERVER : CLIENT,
       &error);
-  DCHECK_EQ(error_code, QUIC_NO_ERROR) << "Configuration failed: " << error;
+  QUICHE_DCHECK_EQ(error_code, QUIC_NO_ERROR)
+      << "Configuration failed: " << error;
   if (connection_->version().UsesTls()) {
     if (connection_->perspective() == Perspective::IS_CLIENT) {
       test::QuicConfigPeer::SetReceivedOriginalConnectionId(
@@ -131,7 +132,7 @@
 
 void QuicEndpoint::OnStreamFrame(const QuicStreamFrame& frame) {
   // Verify that the data received always matches the expected.
-  DCHECK(frame.stream_id == kDataStream);
+  QUICHE_DCHECK(frame.stream_id == kDataStream);
   for (size_t i = 0; i < frame.data_length; i++) {
     if (frame.data_buffer[i] != kStreamDataContents) {
       wrong_data_received_ = true;
@@ -139,7 +140,7 @@
   }
   offsets_received_.Add(frame.offset, frame.offset + frame.data_length);
   // Sanity check against very pathological connections.
-  DCHECK_LE(offsets_received_.Size(), 1000u);
+  QUICHE_DCHECK_LE(offsets_received_.Size(), 1000u);
 }
 
 void QuicEndpoint::OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {}
@@ -184,18 +185,18 @@
 }
 
 void QuicEndpoint::OnFrameLost(const QuicFrame& frame) {
-  DCHECK(notifier_);
+  QUICHE_DCHECK(notifier_);
   notifier_->OnFrameLost(frame);
 }
 
 void QuicEndpoint::RetransmitFrames(const QuicFrames& frames,
                                     TransmissionType type) {
-  DCHECK(notifier_);
+  QUICHE_DCHECK(notifier_);
   notifier_->RetransmitFrames(frames, type);
 }
 
 bool QuicEndpoint::IsFrameOutstanding(const QuicFrame& frame) const {
-  DCHECK(notifier_);
+  QUICHE_DCHECK(notifier_);
   return notifier_->IsFrameOutstanding(frame);
 }
 
@@ -243,7 +244,7 @@
     QuicConsumedData consumed_data = connection_->SendStreamData(
         kDataStream, transmission_size, bytes_transferred_, NO_FIN);
 
-    DCHECK(consumed_data.bytes_consumed <= transmission_size);
+    QUICHE_DCHECK(consumed_data.bytes_consumed <= transmission_size);
     bytes_transferred_ += consumed_data.bytes_consumed;
     bytes_to_transfer_ -= consumed_data.bytes_consumed;
     if (consumed_data.bytes_consumed != transmission_size) {
diff --git a/quic/test_tools/simulator/quic_endpoint_base.cc b/quic/test_tools/simulator/quic_endpoint_base.cc
index d221888..a563a29 100644
--- a/quic/test_tools/simulator/quic_endpoint_base.cc
+++ b/quic/test_tools/simulator/quic_endpoint_base.cc
@@ -133,9 +133,9 @@
     const QuicIpAddress& /*self_address*/,
     const QuicSocketAddress& /*peer_address*/,
     PerPacketOptions* options) {
-  DCHECK(!IsWriteBlocked());
-  DCHECK(options == nullptr);
-  DCHECK(buf_len <= kMaxOutgoingPacketSize);
+  QUICHE_DCHECK(!IsWriteBlocked());
+  QUICHE_DCHECK(options == nullptr);
+  QUICHE_DCHECK(buf_len <= kMaxOutgoingPacketSize);
 
   // Instead of losing a packet, become write-blocked when the egress queue is
   // full.
diff --git a/quic/test_tools/simulator/simulator.cc b/quic/test_tools/simulator/simulator.cc
index 9aa10ab..8d68ee4 100644
--- a/quic/test_tools/simulator/simulator.cc
+++ b/quic/test_tools/simulator/simulator.cc
@@ -48,15 +48,15 @@
   auto emplace_names_result = actor_names_.insert(actor->name());
 
   // Ensure that the object was actually placed into the map.
-  DCHECK(emplace_times_result.second);
-  DCHECK(emplace_names_result.second);
+  QUICHE_DCHECK(emplace_times_result.second);
+  QUICHE_DCHECK(emplace_names_result.second);
 }
 
 void Simulator::RemoveActor(Actor* actor) {
   auto scheduled_time_it = scheduled_times_.find(actor);
   auto actor_names_it = actor_names_.find(actor->name());
-  DCHECK(scheduled_time_it != scheduled_times_.end());
-  DCHECK(actor_names_it != actor_names_.end());
+  QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
+  QUICHE_DCHECK(actor_names_it != actor_names_.end());
 
   QuicTime scheduled_time = scheduled_time_it->second;
   if (scheduled_time != QuicTime::Infinite()) {
@@ -69,7 +69,7 @@
 
 void Simulator::Schedule(Actor* actor, QuicTime new_time) {
   auto scheduled_time_it = scheduled_times_.find(actor);
-  DCHECK(scheduled_time_it != scheduled_times_.end());
+  QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
   QuicTime scheduled_time = scheduled_time_it->second;
 
   if (scheduled_time <= new_time) {
@@ -86,10 +86,10 @@
 
 void Simulator::Unschedule(Actor* actor) {
   auto scheduled_time_it = scheduled_times_.find(actor);
-  DCHECK(scheduled_time_it != scheduled_times_.end());
+  QUICHE_DCHECK(scheduled_time_it != scheduled_times_.end());
   QuicTime scheduled_time = scheduled_time_it->second;
 
-  DCHECK(scheduled_time != QuicTime::Infinite());
+  QUICHE_DCHECK(scheduled_time != QuicTime::Infinite());
   auto range = schedule_.equal_range(scheduled_time);
   for (auto it = range.first; it != range.second; ++it) {
     if (it->second == actor) {
@@ -98,7 +98,7 @@
       return;
     }
   }
-  DCHECK(false);
+  QUICHE_DCHECK(false);
 }
 
 const QuicClock* Simulator::GetClock() const {
@@ -129,7 +129,7 @@
 }
 
 void Simulator::RunFor(QuicTime::Delta time_span) {
-  DCHECK(!run_for_alarm_->IsSet());
+  QUICHE_DCHECK(!run_for_alarm_->IsSet());
 
   // RunFor() ensures that the simulation stops at the exact time specified by
   // scheduling an alarm at that point and using that alarm to abort the
@@ -141,8 +141,8 @@
   run_for_should_stop_ = false;
   bool simulation_result = RunUntil([this]() { return run_for_should_stop_; });
 
-  DCHECK(simulation_result);
-  DCHECK(clock_.Now() == end_time);
+  QUICHE_DCHECK(simulation_result);
+  QUICHE_DCHECK(clock_.Now() == end_time);
 }
 
 void Simulator::HandleNextScheduledActor() {
diff --git a/quic/test_tools/simulator/traffic_policer.cc b/quic/test_tools/simulator/traffic_policer.cc
index e44e67f..be62669 100644
--- a/quic/test_tools/simulator/traffic_policer.cc
+++ b/quic/test_tools/simulator/traffic_policer.cc
@@ -45,7 +45,7 @@
   }
 
   auto bucket = token_buckets_.find(packet.destination);
-  DCHECK(bucket != token_buckets_.end());
+  QUICHE_DCHECK(bucket != token_buckets_.end());
 
   // Silently drop the packet on the floor if out of tokens
   if (bucket->second < packet.size) {
diff --git a/quic/tools/quic_client.cc b/quic/tools/quic_client.cc
index 131ed33..f8375ab 100644
--- a/quic/tools/quic_client.cc
+++ b/quic/tools/quic_client.cc
@@ -48,7 +48,7 @@
     return QuicSocketAddress();
   }
 
-  CHECK(info_list != nullptr);
+  QUICHE_CHECK(info_list != nullptr);
   std::unique_ptr<addrinfo, void (*)(addrinfo*)> info_list_owned(info_list,
                                                                  freeaddrinfo);
   return QuicSocketAddress(info_list->ai_addr, info_list->ai_addrlen);
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index 6666dbb..57cfcb5 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -55,7 +55,7 @@
     client_->session()->MigratePath(
         migration_context->self_address(), migration_context->peer_address(),
         migration_context->WriterToUse(), /*owns_writer=*/false);
-    DCHECK(migration_context->WriterToUse() != nullptr);
+    QUICHE_DCHECK(migration_context->WriterToUse() != nullptr);
     // Hand the ownership of the alternative writer to the client.
     client_->set_writer(migration_context->ReleaseWriter());
   }
@@ -154,8 +154,8 @@
 }
 
 void QuicClientBase::StartConnect() {
-  DCHECK(initialized_);
-  DCHECK(!connected());
+  QUICHE_DCHECK(initialized_);
+  QUICHE_DCHECK(!connected());
   QuicPacketWriter* writer = network_helper_->CreateQuicPacketWriter();
   ParsedQuicVersion mutual_version = UnsupportedQuicVersion();
   const bool can_reconnect_with_different_version =
@@ -205,7 +205,7 @@
 }
 
 void QuicClientBase::Disconnect() {
-  DCHECK(initialized_);
+  QUICHE_DCHECK(initialized_);
 
   initialized_ = false;
   if (connected()) {
@@ -236,7 +236,7 @@
 
   network_helper_->RunEventLoop();
 
-  DCHECK(session() != nullptr);
+  QUICHE_DCHECK(session() != nullptr);
   ParsedQuicVersion version = UnsupportedQuicVersion();
   if (!connected() && CanReconnectWithDifferentVersion(&version)) {
     QUIC_DLOG(INFO) << "Can reconnect with version: " << version
@@ -273,9 +273,9 @@
 }
 
 bool QuicClientBase::ValidateAndMigrateSocket(const QuicIpAddress& new_host) {
-  DCHECK(VersionHasIetfQuicFrames(
-             session_->connection()->version().transport_version) &&
-         session_->connection()->use_path_validator());
+  QUICHE_DCHECK(VersionHasIetfQuicFrames(
+                    session_->connection()->version().transport_version) &&
+                session_->connection()->use_path_validator());
   if (!connected()) {
     return false;
   }
diff --git a/quic/tools/quic_client_epoll_network_helper.cc b/quic/tools/quic_client_epoll_network_helper.cc
index e31ef11..2049f15 100644
--- a/quic/tools/quic_client_epoll_network_helper.cc
+++ b/quic/tools/quic_client_epoll_network_helper.cc
@@ -110,7 +110,7 @@
   if (fd > -1) {
     epoll_server_->UnregisterFD(fd);
     int rc = close(fd);
-    DCHECK_EQ(0, rc);
+    QUICHE_DCHECK_EQ(0, rc);
   }
 }
 
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index 822c61b..f67a338 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -378,7 +378,7 @@
       break;
     }
   }
-  CHECK(version.IsKnown());
+  QUICHE_CHECK(version.IsKnown());
   QuicEnableVersion(version);
 
   std::cout << "Attempting interop with version " << version << std::endl;
diff --git a/quic/tools/quic_client_test.cc b/quic/tools/quic_client_test.cc
index 0eec86f..160f255 100644
--- a/quic/tools/quic_client_test.cc
+++ b/quic/tools/quic_client_test.cc
@@ -29,7 +29,8 @@
 std::string ReadLink(const std::string& path) {
   std::string result(PATH_MAX, '\0');
   ssize_t result_size = readlink(path.c_str(), &result[0], result.size());
-  CHECK(result_size > 0 && static_cast<size_t>(result_size) < result.size());
+  QUICHE_CHECK(result_size > 0 &&
+               static_cast<size_t>(result_size) < result.size());
   result.resize(result_size);
   return result;
 }
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index df2f604..c67e5b3 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -105,7 +105,7 @@
 
 void QuicMemoryCacheBackend::ResourceFile::SetHostPathFromBase(
     absl::string_view base) {
-  DCHECK(base[0] != '/') << base;
+  QUICHE_DCHECK(base[0] != '/') << base;
   size_t path_start = base.find_first_of('/');
   if (path_start == absl::string_view::npos) {
     host_ = std::string(base);
@@ -359,7 +359,8 @@
     Http2HeaderBlock response_trailers) {
   QuicWriterMutexLock lock(&response_mutex_);
 
-  DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
+  QUICHE_DCHECK(!host.empty())
+      << "Host must be populated, e.g. \"www.google.com\"";
   std::string key = GetKey(host, path);
   if (QuicContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index 937921e..9d67b09 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -82,7 +82,7 @@
   }
   void OnDecryptedPacket(size_t /*length*/, EncryptionLevel level) override {
     // This only currently supports "decrypting" null encrypted packets.
-    DCHECK_EQ(ENCRYPTION_INITIAL, level);
+    QUICHE_DCHECK_EQ(ENCRYPTION_INITIAL, level);
     std::cerr << "OnDecryptedPacket\n";
   }
   bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
diff --git a/quic/tools/quic_server.cc b/quic/tools/quic_server.cc
index f10d672..fe10d12 100644
--- a/quic/tools/quic_server.cc
+++ b/quic/tools/quic_server.cc
@@ -82,7 +82,7 @@
       quic_simple_server_backend_(quic_simple_server_backend),
       expected_server_connection_id_length_(
           expected_server_connection_id_length) {
-  DCHECK(quic_simple_server_backend_);
+  QUICHE_DCHECK(quic_simple_server_backend_);
   Initialize();
 }
 
@@ -190,7 +190,7 @@
 }
 
 void QuicServer::OnEvent(int fd, QuicEpollEvent* event) {
-  DCHECK_EQ(fd, fd_);
+  QUICHE_DCHECK_EQ(fd, fd_);
   event->out_ready_mask = 0;
 
   if (event->in_events & EPOLLIN) {
diff --git a/quic/tools/quic_server_test.cc b/quic/tools/quic_server_test.cc
index e48ccec..80ab7f7 100644
--- a/quic/tools/quic_server_test.cc
+++ b/quic/tools/quic_server_test.cc
@@ -118,7 +118,7 @@
   StartListening();
   bool more_chlos = true;
   MockQuicSimpleDispatcher* dispatcher_ = server_.mock_dispatcher();
-  DCHECK(dispatcher_ != nullptr);
+  QUICHE_DCHECK(dispatcher_ != nullptr);
   EXPECT_CALL(*dispatcher_, OnCanWrite()).Times(testing::AnyNumber());
   EXPECT_CALL(*dispatcher_, ProcessBufferedChlos(_)).Times(2);
   EXPECT_CALL(*dispatcher_, HasPendingWrites()).Times(testing::AnyNumber());
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 740b591..044998c 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -35,7 +35,7 @@
       highest_promised_stream_id_(
           QuicUtils::GetInvalidStreamId(connection->transport_version())),
       quic_simple_server_backend_(quic_simple_server_backend) {
-  DCHECK(quic_simple_server_backend_);
+  QUICHE_DCHECK(quic_simple_server_backend_);
 }
 
 QuicSimpleServerSession::~QuicSimpleServerSession() {
@@ -115,7 +115,7 @@
 
 QuicSimpleServerStream*
 QuicSimpleServerSession::CreateOutgoingBidirectionalStream() {
-  DCHECK(false);
+  QUICHE_DCHECK(false);
   return nullptr;
 }
 
@@ -206,8 +206,8 @@
   while (!promised_streams_.empty() &&
          ShouldCreateOutgoingUnidirectionalStream()) {
     PromisedStreamInfo& promised_info = promised_streams_.front();
-    DCHECK_EQ(next_outgoing_unidirectional_stream_id(),
-              promised_info.stream_id);
+    QUICHE_DCHECK_EQ(next_outgoing_unidirectional_stream_id(),
+                     promised_info.stream_id);
 
     if (promised_info.is_cancelled) {
       // This stream has been reset by client. Skip this stream id.
@@ -219,8 +219,8 @@
     QuicSimpleServerStream* promised_stream =
         static_cast<QuicSimpleServerStream*>(
             CreateOutgoingUnidirectionalStream());
-    DCHECK_NE(promised_stream, nullptr);
-    DCHECK_EQ(promised_info.stream_id, promised_stream->id());
+    QUICHE_DCHECK_NE(promised_stream, nullptr);
+    QUICHE_DCHECK_EQ(promised_info.stream_id, promised_stream->id());
     QUIC_DLOG(INFO) << "created server push stream " << promised_stream->id();
 
     promised_stream->SetPriority(promised_info.precedence);
@@ -245,7 +245,7 @@
   size_t previous_static_stream_count = num_static_streams();
   QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams();
   size_t current_static_stream_count = num_static_streams();
-  DCHECK_GE(current_static_stream_count, previous_static_stream_count);
+  QUICHE_DCHECK_GE(current_static_stream_count, previous_static_stream_count);
   highest_promised_stream_id_ +=
       QuicUtils::StreamIdDelta(transport_version()) *
       (current_static_stream_count - previous_static_stream_count);
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index 7a439c2..800608b 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -34,7 +34,7 @@
       content_length_(-1),
       generate_bytes_length_(0),
       quic_simple_server_backend_(quic_simple_server_backend) {
-  DCHECK(quic_simple_server_backend_);
+  QUICHE_DCHECK(quic_simple_server_backend_);
 }
 
 QuicSimpleServerStream::QuicSimpleServerStream(
@@ -46,7 +46,7 @@
       content_length_(-1),
       generate_bytes_length_(0),
       quic_simple_server_backend_(quic_simple_server_backend) {
-  DCHECK(quic_simple_server_backend_);
+  QUICHE_DCHECK(quic_simple_server_backend_);
 }
 
 QuicSimpleServerStream::~QuicSimpleServerStream() {
@@ -132,7 +132,7 @@
   content_length_ = 0;
   QUIC_DVLOG(1) << "Stream " << id()
                 << " ready to receive server push response.";
-  DCHECK(reading_stopped());
+  QUICHE_DCHECK(reading_stopped());
 
   // Directly send response based on the emulated request_headers_.
   SendResponse();
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index c83de42..cee1753 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -80,7 +80,7 @@
 
   absl::string_view GetHeader(absl::string_view key) const {
     auto it = request_headers_.find(key);
-    DCHECK(it != request_headers_.end());
+    QUICHE_DCHECK(it != request_headers_.end());
     return it->second;
   }
 
@@ -211,11 +211,11 @@
     if (write_length > 0) {
       auto buf = std::make_unique<char[]>(write_length);
       QuicStream* stream = GetOrCreateStream(id);
-      DCHECK(stream);
+      QUICHE_DCHECK(stream);
       QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
       stream->WriteStreamData(offset, write_length, &writer);
     } else {
-      DCHECK(state != NO_FIN);
+      QUICHE_DCHECK(state != NO_FIN);
     }
     return QuicConsumedData(write_length, state != NO_FIN);
   }
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index 4fe5d1a..d28eb77 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -77,7 +77,7 @@
 }
 
 void QuicSpdyClientBase::OnClose(QuicSpdyStream* stream) {
-  DCHECK(stream != nullptr);
+  QUICHE_DCHECK(stream != nullptr);
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
 
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 45c2531..15cdc29 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -337,7 +337,7 @@
   // Construct the string body from flags, if provided.
   std::string body = GetQuicFlag(FLAGS_body);
   if (!GetQuicFlag(FLAGS_body_hex).empty()) {
-    DCHECK(GetQuicFlag(FLAGS_body).empty())
+    QUICHE_DCHECK(GetQuicFlag(FLAGS_body).empty())
         << "Only set one of --body and --body_hex.";
     body = absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex));
   }
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index 42250d0..ad93115 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -51,7 +51,7 @@
 
   void OnFinRead() override {
     bool success = stream_->SendFin();
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   }
 
   void OnCanWrite() override {
@@ -79,7 +79,7 @@
 
   void OnCanRead() override {
     bool success = stream_->Read(&buffer_);
-    DCHECK(success);
+    QUICHE_DCHECK(success);
   }
 
   void OnFinRead() override {
@@ -114,7 +114,7 @@
     }
     data_ = "";
     bool fin_sent = stream_->SendFin();
-    DCHECK(fin_sent);
+    QUICHE_DCHECK(fin_sent);
   }
 
  private: