diff --git a/http2/hpack/decoder/hpack_block_collector.cc b/http2/hpack/decoder/hpack_block_collector.cc
index 5b2c6b7..1137be5 100644
--- a/http2/hpack/decoder/hpack_block_collector.cc
+++ b/http2/hpack/decoder/hpack_block_collector.cc
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <memory>
 
-#include "base/logging.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 
 using ::testing::AssertionResult;
@@ -55,7 +55,7 @@
 
 void HpackBlockCollector::PushPendingEntry() {
   EXPECT_TRUE(pending_entry_.IsComplete());
-  DVLOG(2) << "PushPendingEntry: " << pending_entry_;
+  HTTP2_DVLOG(2) << "PushPendingEntry: " << pending_entry_;
   entries_.push_back(pending_entry_);
   EXPECT_TRUE(entries_.back().IsComplete());
   pending_entry_.Clear();
diff --git a/http2/hpack/decoder/hpack_block_decoder.cc b/http2/hpack/decoder/hpack_block_decoder.cc
index c6882d2..656f8e9 100644
--- a/http2/hpack/decoder/hpack_block_decoder.cc
+++ b/http2/hpack/decoder/hpack_block_decoder.cc
@@ -6,15 +6,15 @@
 
 #include <cstdint>
 
-#include "base/logging.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 
 namespace http2 {
 
 DecodeStatus HpackBlockDecoder::Decode(DecodeBuffer* db) {
   if (!before_entry_) {
-    DVLOG(2) << "HpackBlockDecoder::Decode resume entry, db->Remaining="
-             << db->Remaining();
+    HTTP2_DVLOG(2) << "HpackBlockDecoder::Decode resume entry, db->Remaining="
+                   << db->Remaining();
     DecodeStatus status = entry_decoder_.Resume(db, listener_);
     switch (status) {
       case DecodeStatus::kDecodeDone:
@@ -29,8 +29,8 @@
   }
   DCHECK(before_entry_);
   while (db->HasData()) {
-    DVLOG(2) << "HpackBlockDecoder::Decode start entry, db->Remaining="
-             << db->Remaining();
+    HTTP2_DVLOG(2) << "HpackBlockDecoder::Decode start entry, db->Remaining="
+                   << db->Remaining();
     DecodeStatus status = entry_decoder_.Start(db, listener_);
     switch (status) {
       case DecodeStatus::kDecodeDone:
diff --git a/http2/hpack/decoder/hpack_block_decoder.h b/http2/hpack/decoder/hpack_block_decoder.h
index e8b23e1..a17664f 100644
--- a/http2/hpack/decoder/hpack_block_decoder.h
+++ b/http2/hpack/decoder/hpack_block_decoder.h
@@ -10,12 +10,12 @@
 // or dynamic table support, so table indices remain indices at this level.
 // Reports the entries to an HpackEntryDecoderListener.
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_decoder.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_decoder_listener.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 
 namespace http2 {
@@ -35,7 +35,7 @@
   // to be called from an implementation of Http2FrameDecoderListener's
   // OnHeadersStart or OnPushPromiseStart methods.
   void Reset() {
-    DVLOG(2) << "HpackBlockDecoder::Reset";
+    HTTP2_DVLOG(2) << "HpackBlockDecoder::Reset";
     before_entry_ = true;
   }
 
diff --git a/http2/hpack/decoder/hpack_decoder.cc b/http2/hpack/decoder/hpack_decoder.cc
index d6897cb..f2f8584 100644
--- a/http2/hpack/decoder/hpack_decoder.cc
+++ b/http2/hpack/decoder/hpack_decoder.cc
@@ -4,9 +4,9 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder.h"
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_estimate_memory_usage.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 
 namespace http2 {
 
@@ -33,8 +33,8 @@
 }
 
 bool HpackDecoder::StartDecodingBlock() {
-  DVLOG(3) << "HpackDecoder::StartDecodingBlock, error_detected="
-           << (error_detected() ? "true" : "false");
+  HTTP2_DVLOG(3) << "HpackDecoder::StartDecodingBlock, error_detected="
+                 << (error_detected() ? "true" : "false");
   if (error_detected()) {
     return false;
   }
@@ -47,9 +47,9 @@
 }
 
 bool HpackDecoder::DecodeFragment(DecodeBuffer* db) {
-  DVLOG(3) << "HpackDecoder::DecodeFragment, error_detected="
-           << (error_detected() ? "true" : "false")
-           << ", size=" << db->Remaining();
+  HTTP2_DVLOG(3) << "HpackDecoder::DecodeFragment, error_detected="
+                 << (error_detected() ? "true" : "false")
+                 << ", size=" << db->Remaining();
   if (error_detected()) {
     return false;
   }
@@ -74,8 +74,8 @@
 }
 
 bool HpackDecoder::EndDecodingBlock() {
-  DVLOG(3) << "HpackDecoder::EndDecodingBlock, error_detected="
-           << (error_detected() ? "true" : "false");
+  HTTP2_DVLOG(3) << "HpackDecoder::EndDecodingBlock, error_detected="
+                 << (error_detected() ? "true" : "false");
   if (error_detected()) {
     return false;
   }
@@ -95,10 +95,10 @@
 bool HpackDecoder::error_detected() {
   if (!error_detected_) {
     if (entry_buffer_.error_detected()) {
-      DVLOG(2) << "HpackDecoder::error_detected in entry_buffer_";
+      HTTP2_DVLOG(2) << "HpackDecoder::error_detected in entry_buffer_";
       error_detected_ = true;
     } else if (decoder_state_.error_detected()) {
-      DVLOG(2) << "HpackDecoder::error_detected in decoder_state_";
+      HTTP2_DVLOG(2) << "HpackDecoder::error_detected in decoder_state_";
       error_detected_ = true;
     }
   }
@@ -110,9 +110,9 @@
 }
 
 void HpackDecoder::ReportError(Http2StringPiece error_message) {
-  DVLOG(3) << "HpackDecoder::ReportError is new="
-           << (!error_detected_ ? "true" : "false")
-           << ", error_message: " << error_message;
+  HTTP2_DVLOG(3) << "HpackDecoder::ReportError is new="
+                 << (!error_detected_ ? "true" : "false")
+                 << ", error_message: " << error_message;
   if (!error_detected_) {
     error_detected_ = true;
     decoder_state_.listener()->OnHeaderErrorDetected(error_message);
diff --git a/http2/hpack/decoder/hpack_decoder_state.cc b/http2/hpack/decoder/hpack_decoder_state.cc
index 2ddf421..921d48c 100644
--- a/http2/hpack/decoder/hpack_decoder_state.cc
+++ b/http2/hpack/decoder/hpack_decoder_state.cc
@@ -4,9 +4,9 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_state.h"
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/hpack/hpack_string.h"
 #include "net/third_party/quiche/src/http2/http2_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_macros.h"
 
 namespace http2 {
@@ -41,21 +41,21 @@
 
 void HpackDecoderState::ApplyHeaderTableSizeSetting(
     uint32_t header_table_size) {
-  DVLOG(2) << "HpackDecoderState::ApplyHeaderTableSizeSetting("
-           << header_table_size << ")";
+  HTTP2_DVLOG(2) << "HpackDecoderState::ApplyHeaderTableSizeSetting("
+                 << header_table_size << ")";
   DCHECK_LE(lowest_header_table_size_, final_header_table_size_);
   if (header_table_size < lowest_header_table_size_) {
     lowest_header_table_size_ = header_table_size;
   }
   final_header_table_size_ = header_table_size;
-  DVLOG(2) << "low water mark: " << lowest_header_table_size_;
-  DVLOG(2) << "final limit: " << final_header_table_size_;
+  HTTP2_DVLOG(2) << "low water mark: " << lowest_header_table_size_;
+  HTTP2_DVLOG(2) << "final limit: " << final_header_table_size_;
 }
 
 // Called to notify this object that we're starting to decode an HPACK block
 // (e.g. a HEADERS or PUSH_PROMISE frame's header has been decoded).
 void HpackDecoderState::OnHeaderBlockStart() {
-  DVLOG(2) << "HpackDecoderState::OnHeaderBlockStart";
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnHeaderBlockStart";
   // This instance can't be reused after an error has been detected, as we must
   // assume that the encoder and decoder compression states are no longer
   // synchronized.
@@ -72,14 +72,14 @@
       (lowest_header_table_size_ <
            decoder_tables_.current_header_table_size() ||
        final_header_table_size_ < decoder_tables_.header_table_size_limit());
-  DVLOG(2) << "HpackDecoderState::OnHeaderListStart "
-           << "require_dynamic_table_size_update_="
-           << require_dynamic_table_size_update_;
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnHeaderListStart "
+                 << "require_dynamic_table_size_update_="
+                 << require_dynamic_table_size_update_;
   listener_->OnHeaderListStart();
 }
 
 void HpackDecoderState::OnIndexedHeader(size_t index) {
-  DVLOG(2) << "HpackDecoderState::OnIndexedHeader: " << index;
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnIndexedHeader: " << index;
   if (error_detected_) {
     return;
   }
@@ -101,8 +101,9 @@
     HpackEntryType entry_type,
     size_t name_index,
     HpackDecoderStringBuffer* value_buffer) {
-  DVLOG(2) << "HpackDecoderState::OnNameIndexAndLiteralValue " << entry_type
-           << ", " << name_index << ", " << value_buffer->str();
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnNameIndexAndLiteralValue "
+                 << entry_type << ", " << name_index << ", "
+                 << value_buffer->str();
   if (error_detected_) {
     return;
   }
@@ -127,8 +128,8 @@
     HpackEntryType entry_type,
     HpackDecoderStringBuffer* name_buffer,
     HpackDecoderStringBuffer* value_buffer) {
-  DVLOG(2) << "HpackDecoderState::OnLiteralNameAndValue " << entry_type << ", "
-           << name_buffer->str() << ", " << value_buffer->str();
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnLiteralNameAndValue " << entry_type
+                 << ", " << name_buffer->str() << ", " << value_buffer->str();
   if (error_detected_) {
     return;
   }
@@ -146,11 +147,11 @@
 }
 
 void HpackDecoderState::OnDynamicTableSizeUpdate(size_t size_limit) {
-  DVLOG(2) << "HpackDecoderState::OnDynamicTableSizeUpdate " << size_limit
-           << ", required="
-           << (require_dynamic_table_size_update_ ? "true" : "false")
-           << ", allowed="
-           << (allow_dynamic_table_size_update_ ? "true" : "false");
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnDynamicTableSizeUpdate " << size_limit
+                 << ", required="
+                 << (require_dynamic_table_size_update_ ? "true" : "false")
+                 << ", allowed="
+                 << (allow_dynamic_table_size_update_ ? "true" : "false");
   if (error_detected_) {
     return;
   }
@@ -185,14 +186,14 @@
 }
 
 void HpackDecoderState::OnHpackDecodeError(Http2StringPiece error_message) {
-  DVLOG(2) << "HpackDecoderState::OnHpackDecodeError " << error_message;
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnHpackDecodeError " << error_message;
   if (!error_detected_) {
     ReportError(error_message);
   }
 }
 
 void HpackDecoderState::OnHeaderBlockEnd() {
-  DVLOG(2) << "HpackDecoderState::OnHeaderBlockEnd";
+  HTTP2_DVLOG(2) << "HpackDecoderState::OnHeaderBlockEnd";
   if (error_detected_) {
     return;
   }
@@ -206,9 +207,9 @@
 }
 
 void HpackDecoderState::ReportError(Http2StringPiece error_message) {
-  DVLOG(2) << "HpackDecoderState::ReportError is new="
-           << (!error_detected_ ? "true" : "false")
-           << ", error_message: " << error_message;
+  HTTP2_DVLOG(2) << "HpackDecoderState::ReportError is new="
+                 << (!error_detected_ ? "true" : "false")
+                 << ", error_message: " << error_message;
   if (!error_detected_) {
     listener_->OnHeaderErrorDetected(error_message);
     error_detected_ = true;
diff --git a/http2/hpack/decoder/hpack_decoder_state_test.cc b/http2/hpack/decoder/hpack_decoder_state_test.cc
index 115827e..cbc4224 100644
--- a/http2/hpack/decoder/hpack_decoder_state_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_state_test.cc
@@ -9,12 +9,12 @@
 #include <utility>
 #include <vector>
 
-#include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/hpack_string.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/http2_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 
diff --git a/http2/hpack/decoder/hpack_decoder_string_buffer.cc b/http2/hpack/decoder/hpack_decoder_string_buffer.cc
index b20c37a..76431a6 100644
--- a/http2/hpack/decoder/hpack_decoder_string_buffer.cc
+++ b/http2/hpack/decoder/hpack_decoder_string_buffer.cc
@@ -6,9 +6,9 @@
 
 #include <utility>
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_bug_tracker.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_estimate_memory_usage.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 
 namespace http2 {
@@ -57,12 +57,12 @@
 HpackDecoderStringBuffer::~HpackDecoderStringBuffer() = default;
 
 void HpackDecoderStringBuffer::Reset() {
-  DVLOG(3) << "HpackDecoderStringBuffer::Reset";
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::Reset";
   state_ = State::RESET;
 }
 
 void HpackDecoderStringBuffer::Set(Http2StringPiece value, bool is_static) {
-  DVLOG(2) << "HpackDecoderStringBuffer::Set";
+  HTTP2_DVLOG(2) << "HpackDecoderStringBuffer::Set";
   DCHECK_EQ(state_, State::RESET);
   value_ = value;
   state_ = State::COMPLETE;
@@ -73,7 +73,7 @@
 }
 
 void HpackDecoderStringBuffer::OnStart(bool huffman_encoded, size_t len) {
-  DVLOG(2) << "HpackDecoderStringBuffer::OnStart";
+  HTTP2_DVLOG(2) << "HpackDecoderStringBuffer::OnStart";
   DCHECK_EQ(state_, State::RESET);
 
   remaining_len_ = len;
@@ -106,8 +106,8 @@
 }
 
 bool HpackDecoderStringBuffer::OnData(const char* data, size_t len) {
-  DVLOG(2) << "HpackDecoderStringBuffer::OnData state=" << state_
-           << ", backing=" << backing_;
+  HTTP2_DVLOG(2) << "HpackDecoderStringBuffer::OnData state=" << state_
+                 << ", backing=" << backing_;
   DCHECK_EQ(state_, State::COLLECTING);
   DCHECK_LE(len, remaining_len_);
   remaining_len_ -= len;
@@ -145,7 +145,7 @@
 }
 
 bool HpackDecoderStringBuffer::OnEnd() {
-  DVLOG(2) << "HpackDecoderStringBuffer::OnEnd";
+  HTTP2_DVLOG(2) << "HpackDecoderStringBuffer::OnEnd";
   DCHECK_EQ(state_, State::COLLECTING);
   DCHECK_EQ(0u, remaining_len_);
 
@@ -164,11 +164,12 @@
 }
 
 void HpackDecoderStringBuffer::BufferStringIfUnbuffered() {
-  DVLOG(3) << "HpackDecoderStringBuffer::BufferStringIfUnbuffered state="
-           << state_ << ", backing=" << backing_;
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::BufferStringIfUnbuffered state="
+                 << state_ << ", backing=" << backing_;
   if (state_ != State::RESET && backing_ == Backing::UNBUFFERED) {
-    DVLOG(2) << "HpackDecoderStringBuffer buffering Http2String of length "
-             << value_.size();
+    HTTP2_DVLOG(2)
+        << "HpackDecoderStringBuffer buffering Http2String of length "
+        << value_.size();
     buffer_.assign(value_.data(), value_.size());
     if (state_ == State::COMPLETE) {
       value_ = buffer_;
@@ -178,23 +179,23 @@
 }
 
 bool HpackDecoderStringBuffer::IsBuffered() const {
-  DVLOG(3) << "HpackDecoderStringBuffer::IsBuffered";
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::IsBuffered";
   return state_ != State::RESET && backing_ == Backing::BUFFERED;
 }
 
 size_t HpackDecoderStringBuffer::BufferedLength() const {
-  DVLOG(3) << "HpackDecoderStringBuffer::BufferedLength";
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::BufferedLength";
   return IsBuffered() ? buffer_.size() : 0;
 }
 
 Http2StringPiece HpackDecoderStringBuffer::str() const {
-  DVLOG(3) << "HpackDecoderStringBuffer::str";
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::str";
   DCHECK_EQ(state_, State::COMPLETE);
   return value_;
 }
 
 Http2String HpackDecoderStringBuffer::ReleaseString() {
-  DVLOG(3) << "HpackDecoderStringBuffer::ReleaseString";
+  HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::ReleaseString";
   DCHECK_EQ(state_, State::COMPLETE);
   DCHECK_EQ(backing_, Backing::BUFFERED);
   if (state_ == State::COMPLETE) {
diff --git a/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc b/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
index 009b894..11b0d97 100644
--- a/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
@@ -8,9 +8,9 @@
 
 #include <initializer_list>
 
-#include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
@@ -31,10 +31,10 @@
   State state() const { return buf_.state_for_testing(); }
   Backing backing() const { return buf_.backing_for_testing(); }
 
-  // We want to know that LOG(x) << buf_ will work in production should that
-  // be needed, so we test that it outputs the expected values.
+  // We want to know that HTTP2_LOG(x) << buf_ will work in production should
+  // that be needed, so we test that it outputs the expected values.
   AssertionResult VerifyLogHasSubstrs(std::initializer_list<Http2String> strs) {
-    VLOG(1) << buf_;
+    HTTP2_VLOG(1) << buf_;
     std::ostringstream ss;
     buf_.OutputDebugStringTo(ss);
     Http2String dbg_str(ss.str());
@@ -54,7 +54,7 @@
   EXPECT_TRUE(VerifyLogHasSubstrs({"state=RESET"}));
 
   buf_.Set(data, /*is_static*/ true);
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
   EXPECT_EQ(state(), State::COMPLETE);
   EXPECT_EQ(backing(), Backing::STATIC);
   EXPECT_EQ(data, buf_.str());
@@ -75,13 +75,13 @@
 TEST_F(HpackDecoderStringBufferTest, PlainWhole) {
   Http2StringPiece data("some text.");
 
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
   EXPECT_EQ(state(), State::RESET);
 
   buf_.OnStart(/*huffman_encoded*/ false, data.size());
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::RESET);
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   EXPECT_TRUE(buf_.OnData(data.data(), data.size()));
   EXPECT_EQ(state(), State::COLLECTING);
@@ -101,7 +101,7 @@
   // Now force it to buffer the string, after which it will still have the same
   // string value, but the backing store will be different.
   buf_.BufferStringIfUnbuffered();
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(buf_.BufferedLength(), data.size());
   EXPECT_EQ(data, buf_.str());
@@ -126,7 +126,7 @@
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(buf_.BufferedLength(), part1.size());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   EXPECT_TRUE(buf_.OnData(part2.data(), part2.size()));
   EXPECT_EQ(state(), State::COLLECTING);
@@ -137,7 +137,7 @@
   EXPECT_EQ(state(), State::COMPLETE);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(buf_.BufferedLength(), data.size());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   Http2StringPiece buffered = buf_.str();
   EXPECT_EQ(data, buffered);
@@ -188,31 +188,31 @@
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(0u, buf_.BufferedLength());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   EXPECT_TRUE(buf_.OnData(part1.data(), part1.size()));
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_GT(buf_.BufferedLength(), 0u);
   EXPECT_LT(buf_.BufferedLength(), decoded.size());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   EXPECT_TRUE(buf_.OnData(part2.data(), part2.size()));
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(buf_.BufferedLength(), decoded.size());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   EXPECT_TRUE(buf_.OnEnd());
   EXPECT_EQ(state(), State::COMPLETE);
   EXPECT_EQ(backing(), Backing::BUFFERED);
   EXPECT_EQ(buf_.BufferedLength(), decoded.size());
   EXPECT_EQ(decoded, buf_.str());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 
   buf_.Reset();
   EXPECT_EQ(state(), State::RESET);
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 }
 
 TEST_F(HpackDecoderStringBufferTest, InvalidHuffmanOnData) {
@@ -226,7 +226,7 @@
   EXPECT_EQ(state(), State::COLLECTING);
   EXPECT_EQ(backing(), Backing::BUFFERED);
 
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 }
 
 TEST_F(HpackDecoderStringBufferTest, InvalidHuffmanOnEnd) {
@@ -241,7 +241,7 @@
   EXPECT_EQ(backing(), Backing::BUFFERED);
 
   EXPECT_FALSE(buf_.OnEnd());
-  LOG(INFO) << buf_;
+  HTTP2_LOG(INFO) << buf_;
 }
 
 // TODO(jamessynge): Add tests for ReleaseString().
diff --git a/http2/hpack/decoder/hpack_decoder_tables.cc b/http2/hpack/decoder/hpack_decoder_tables.cc
index c88648f..09a18a8 100644
--- a/http2/hpack/decoder/hpack_decoder_tables.cc
+++ b/http2/hpack/decoder/hpack_decoder_tables.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_tables.h"
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 
 namespace http2 {
 namespace {
@@ -60,7 +60,8 @@
 HpackDecoderDynamicTable::~HpackDecoderDynamicTable() = default;
 
 void HpackDecoderDynamicTable::DynamicTableSizeUpdate(size_t size_limit) {
-  DVLOG(3) << "HpackDecoderDynamicTable::DynamicTableSizeUpdate " << size_limit;
+  HTTP2_DVLOG(3) << "HpackDecoderDynamicTable::DynamicTableSizeUpdate "
+                 << size_limit;
   EnsureSizeNoMoreThan(size_limit);
   DCHECK_LE(current_size_, size_limit);
   size_limit_ = size_limit;
@@ -72,12 +73,12 @@
                                       const HpackString& value) {
   HpackDecoderTableEntry entry(name, value);
   size_t entry_size = entry.size();
-  DVLOG(2) << "InsertEntry of size=" << entry_size << "\n     name: " << name
-           << "\n    value: " << value;
+  HTTP2_DVLOG(2) << "InsertEntry of size=" << entry_size
+                 << "\n     name: " << name << "\n    value: " << value;
   if (entry_size > size_limit_) {
-    DVLOG(2) << "InsertEntry: entry larger than table, removing "
-             << table_.size() << " entries, of total size " << current_size_
-             << " bytes.";
+    HTTP2_DVLOG(2) << "InsertEntry: entry larger than table, removing "
+                   << table_.size() << " entries, of total size "
+                   << current_size_ << " bytes.";
     table_.clear();
     current_size_ = 0;
     return false;  // Not inserted because too large.
@@ -85,14 +86,14 @@
   ++insert_count_;
   if (debug_listener_ != nullptr) {
     entry.time_added = debug_listener_->OnEntryInserted(entry, insert_count_);
-    DVLOG(2) << "OnEntryInserted returned time_added=" << entry.time_added
-             << " for insert_count_=" << insert_count_;
+    HTTP2_DVLOG(2) << "OnEntryInserted returned time_added=" << entry.time_added
+                   << " for insert_count_=" << insert_count_;
   }
   size_t insert_limit = size_limit_ - entry_size;
   EnsureSizeNoMoreThan(insert_limit);
   table_.push_front(entry);
   current_size_ += entry_size;
-  DVLOG(2) << "InsertEntry: current_size_=" << current_size_;
+  HTTP2_DVLOG(2) << "InsertEntry: current_size_=" << current_size_;
   DCHECK_GE(current_size_, entry_size);
   DCHECK_LE(current_size_, size_limit_);
   return true;
@@ -112,8 +113,8 @@
 }
 
 void HpackDecoderDynamicTable::EnsureSizeNoMoreThan(size_t limit) {
-  DVLOG(2) << "EnsureSizeNoMoreThan limit=" << limit
-           << ", current_size_=" << current_size_;
+  HTTP2_DVLOG(2) << "EnsureSizeNoMoreThan limit=" << limit
+                 << ", current_size_=" << current_size_;
   // Not the most efficient choice, but any easy way to start.
   while (current_size_ > limit) {
     RemoveLastEntry();
@@ -124,8 +125,8 @@
 void HpackDecoderDynamicTable::RemoveLastEntry() {
   DCHECK(!table_.empty());
   if (!table_.empty()) {
-    DVLOG(2) << "RemoveLastEntry current_size_=" << current_size_
-             << ", last entry size=" << table_.back().size();
+    HTTP2_DVLOG(2) << "RemoveLastEntry current_size_=" << current_size_
+                   << ", last entry size=" << table_.back().size();
     DCHECK_GE(current_size_, table_.back().size());
     current_size_ -= table_.back().size();
     table_.pop_back();
diff --git a/http2/hpack/decoder/hpack_decoder_tables_test.cc b/http2/hpack/decoder/hpack_decoder_tables_test.cc
index a54fa5f..592ce56 100644
--- a/http2/hpack/decoder/hpack_decoder_tables_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_tables_test.cc
@@ -8,10 +8,10 @@
 #include <tuple>
 #include <vector>
 
-#include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
diff --git a/http2/hpack/decoder/hpack_decoder_test.cc b/http2/hpack/decoder/hpack_decoder_test.cc
index 83a0ede..bf2cee5 100644
--- a/http2/hpack/decoder/hpack_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_test.cc
@@ -10,7 +10,6 @@
 #include <utility>
 #include <vector>
 
-#include "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
@@ -22,6 +21,7 @@
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_example.h"
 #include "net/third_party/quiche/src/http2/http2_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
@@ -130,7 +130,7 @@
   }
 
   AssertionResult DecodeBlock(Http2StringPiece block) {
-    VLOG(1) << "HpackDecoderTest::DecodeBlock";
+    HTTP2_VLOG(1) << "HpackDecoderTest::DecodeBlock";
 
     VERIFY_FALSE(decoder_.error_detected());
     VERIFY_TRUE(error_messages_.empty());
diff --git a/http2/hpack/decoder/hpack_entry_collector.cc b/http2/hpack/decoder/hpack_entry_collector.cc
index 9d17465..327075d 100644
--- a/http2/hpack/decoder/hpack_entry_collector.cc
+++ b/http2/hpack/decoder/hpack_entry_collector.cc
@@ -4,10 +4,10 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_collector.h"
 
-#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_collector.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 
diff --git a/http2/hpack/decoder/hpack_entry_decoder.cc b/http2/hpack/decoder/hpack_entry_decoder.cc
index 96b9f06..5e1bd8c 100644
--- a/http2/hpack/decoder/hpack_entry_decoder.cc
+++ b/http2/hpack/decoder/hpack_entry_decoder.cc
@@ -8,9 +8,8 @@
 
 #include <cstdint>
 
-#include "base/logging.h"
-#include "base/macros.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_bug_tracker.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_macros.h"
 
 namespace http2 {
@@ -98,7 +97,8 @@
     switch (state_) {
       case EntryDecoderState::kResumeDecodingType:
         // entry_type_decoder_ returned kDecodeInProgress when last called.
-        DVLOG(1) << "kResumeDecodingType: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kResumeDecodingType: db->Remaining="
+                       << db->Remaining();
         status = entry_type_decoder_.Resume(db);
         if (status != DecodeStatus::kDecodeDone) {
           return status;
@@ -109,7 +109,7 @@
       case EntryDecoderState::kDecodedType:
         // entry_type_decoder_ returned kDecodeDone, now need to decide how
         // to proceed.
-        DVLOG(1) << "kDecodedType: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kDecodedType: db->Remaining=" << db->Remaining();
         if (DispatchOnType(listener)) {
           // All done.
           return DecodeStatus::kDecodeDone;
@@ -117,7 +117,8 @@
         continue;
 
       case EntryDecoderState::kStartDecodingName:
-        DVLOG(1) << "kStartDecodingName: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kStartDecodingName: db->Remaining="
+                       << db->Remaining();
         {
           NameDecoderListener ncb(listener);
           status = string_decoder_.Start(db, &ncb);
@@ -134,7 +135,8 @@
         HTTP2_FALLTHROUGH;
 
       case EntryDecoderState::kStartDecodingValue:
-        DVLOG(1) << "kStartDecodingValue: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kStartDecodingValue: db->Remaining="
+                       << db->Remaining();
         {
           ValueDecoderListener vcb(listener);
           status = string_decoder_.Start(db, &vcb);
@@ -153,7 +155,8 @@
 
       case EntryDecoderState::kResumeDecodingName:
         // The literal name was split across decode buffers.
-        DVLOG(1) << "kResumeDecodingName: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kResumeDecodingName: db->Remaining="
+                       << db->Remaining();
         {
           NameDecoderListener ncb(listener);
           status = string_decoder_.Resume(db, &ncb);
@@ -171,7 +174,8 @@
 
       case EntryDecoderState::kResumeDecodingValue:
         // The literal value was split across decode buffers.
-        DVLOG(1) << "kResumeDecodingValue: db->Remaining=" << db->Remaining();
+        HTTP2_DVLOG(1) << "kResumeDecodingValue: db->Remaining="
+                       << db->Remaining();
         {
           ValueDecoderListener vcb(listener);
           status = string_decoder_.Resume(db, &vcb);
diff --git a/http2/hpack/decoder/hpack_entry_decoder.h b/http2/hpack/decoder/hpack_entry_decoder.h
index fe59d96..5858c1e 100644
--- a/http2/hpack/decoder/hpack_entry_decoder.h
+++ b/http2/hpack/decoder/hpack_entry_decoder.h
@@ -10,7 +10,6 @@
 // must provide a non-empty decode buffer. Continue with calls to Resume() if
 // Start, and any subsequent calls to Resume, returns kDecodeInProgress.
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_decoder_listener.h"
@@ -18,6 +17,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_decoder.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 
 namespace http2 {
diff --git a/http2/hpack/decoder/hpack_entry_decoder_listener.cc b/http2/hpack/decoder/hpack_entry_decoder_listener.cc
index b783b15..a0571c4 100644
--- a/http2/hpack/decoder/hpack_entry_decoder_listener.cc
+++ b/http2/hpack/decoder/hpack_entry_decoder_listener.cc
@@ -4,12 +4,12 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_decoder_listener.h"
 
-#include "base/logging.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 
 namespace http2 {
 
 void HpackEntryDecoderVLoggingListener::OnIndexedHeader(size_t index) {
-  VLOG(1) << "OnIndexedHeader, index=" << index;
+  HTTP2_VLOG(1) << "OnIndexedHeader, index=" << index;
   if (wrapped_) {
     wrapped_->OnIndexedHeader(index);
   }
@@ -18,8 +18,8 @@
 void HpackEntryDecoderVLoggingListener::OnStartLiteralHeader(
     HpackEntryType entry_type,
     size_t maybe_name_index) {
-  VLOG(1) << "OnStartLiteralHeader: entry_type=" << entry_type
-          << ", maybe_name_index=" << maybe_name_index;
+  HTTP2_VLOG(1) << "OnStartLiteralHeader: entry_type=" << entry_type
+                << ", maybe_name_index=" << maybe_name_index;
   if (wrapped_) {
     wrapped_->OnStartLiteralHeader(entry_type, maybe_name_index);
   }
@@ -27,7 +27,7 @@
 
 void HpackEntryDecoderVLoggingListener::OnNameStart(bool huffman_encoded,
                                                     size_t len) {
-  VLOG(1) << "OnNameStart: H=" << huffman_encoded << ", len=" << len;
+  HTTP2_VLOG(1) << "OnNameStart: H=" << huffman_encoded << ", len=" << len;
   if (wrapped_) {
     wrapped_->OnNameStart(huffman_encoded, len);
   }
@@ -35,14 +35,14 @@
 
 void HpackEntryDecoderVLoggingListener::OnNameData(const char* data,
                                                    size_t len) {
-  VLOG(1) << "OnNameData: len=" << len;
+  HTTP2_VLOG(1) << "OnNameData: len=" << len;
   if (wrapped_) {
     wrapped_->OnNameData(data, len);
   }
 }
 
 void HpackEntryDecoderVLoggingListener::OnNameEnd() {
-  VLOG(1) << "OnNameEnd";
+  HTTP2_VLOG(1) << "OnNameEnd";
   if (wrapped_) {
     wrapped_->OnNameEnd();
   }
@@ -50,7 +50,7 @@
 
 void HpackEntryDecoderVLoggingListener::OnValueStart(bool huffman_encoded,
                                                      size_t len) {
-  VLOG(1) << "OnValueStart: H=" << huffman_encoded << ", len=" << len;
+  HTTP2_VLOG(1) << "OnValueStart: H=" << huffman_encoded << ", len=" << len;
   if (wrapped_) {
     wrapped_->OnValueStart(huffman_encoded, len);
   }
@@ -58,21 +58,21 @@
 
 void HpackEntryDecoderVLoggingListener::OnValueData(const char* data,
                                                     size_t len) {
-  VLOG(1) << "OnValueData: len=" << len;
+  HTTP2_VLOG(1) << "OnValueData: len=" << len;
   if (wrapped_) {
     wrapped_->OnValueData(data, len);
   }
 }
 
 void HpackEntryDecoderVLoggingListener::OnValueEnd() {
-  VLOG(1) << "OnValueEnd";
+  HTTP2_VLOG(1) << "OnValueEnd";
   if (wrapped_) {
     wrapped_->OnValueEnd();
   }
 }
 
 void HpackEntryDecoderVLoggingListener::OnDynamicTableSizeUpdate(size_t size) {
-  VLOG(1) << "OnDynamicTableSizeUpdate: size=" << size;
+  HTTP2_VLOG(1) << "OnDynamicTableSizeUpdate: size=" << size;
   if (wrapped_) {
     wrapped_->OnDynamicTableSizeUpdate(size);
   }
diff --git a/http2/hpack/decoder/hpack_entry_type_decoder.cc b/http2/hpack/decoder/hpack_entry_type_decoder.cc
index 121e3d0..7519f5a 100644
--- a/http2/hpack/decoder/hpack_entry_type_decoder.cc
+++ b/http2/hpack/decoder/hpack_entry_type_decoder.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_type_decoder.h"
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_bug_tracker.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 
 namespace http2 {
diff --git a/http2/hpack/decoder/hpack_entry_type_decoder.h b/http2/hpack/decoder/hpack_entry_type_decoder.h
index 79898be..092a844 100644
--- a/http2/hpack/decoder/hpack_entry_type_decoder.h
+++ b/http2/hpack/decoder/hpack_entry_type_decoder.h
@@ -12,12 +12,12 @@
 
 #include <cstdint>
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/hpack/varint/hpack_varint_decoder.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 
 namespace http2 {
diff --git a/http2/hpack/decoder/hpack_entry_type_decoder_test.cc b/http2/hpack/decoder/hpack_entry_type_decoder_test.cc
index afff7cc..60248f3 100644
--- a/http2/hpack/decoder/hpack_entry_type_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_entry_type_decoder_test.cc
@@ -6,9 +6,9 @@
 
 #include <vector>
 
-#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
 
diff --git a/http2/hpack/decoder/hpack_string_decoder.h b/http2/hpack/decoder/hpack_string_decoder.h
index 2128728..e30b36d 100644
--- a/http2/hpack/decoder/hpack_string_decoder.h
+++ b/http2/hpack/decoder/hpack_string_decoder.h
@@ -14,12 +14,11 @@
 #include <algorithm>
 #include <cstdint>
 
-#include "base/logging.h"
-#include "base/macros.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/hpack/varint/hpack_varint_decoder.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_macros.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string.h"
 
@@ -82,7 +81,8 @@
     while (true) {
       switch (state_) {
         case kStartDecodingLength:
-          DVLOG(2) << "kStartDecodingLength: db->Remaining=" << db->Remaining();
+          HTTP2_DVLOG(2) << "kStartDecodingLength: db->Remaining="
+                         << db->Remaining();
           if (!StartDecodingLength(db, cb, &status)) {
             // The length is split across decode buffers.
             return status;
@@ -99,13 +99,13 @@
           HTTP2_FALLTHROUGH;
 
         case kDecodingString:
-          DVLOG(2) << "kDecodingString: db->Remaining=" << db->Remaining()
-                   << "    remaining_=" << remaining_;
+          HTTP2_DVLOG(2) << "kDecodingString: db->Remaining=" << db->Remaining()
+                         << "    remaining_=" << remaining_;
           return DecodeString(db, cb);
 
         case kResumeDecodingLength:
-          DVLOG(2) << "kResumeDecodingLength: db->Remaining="
-                   << db->Remaining();
+          HTTP2_DVLOG(2) << "kResumeDecodingLength: db->Remaining="
+                         << db->Remaining();
           if (!ResumeDecodingLength(db, cb, &status)) {
             return status;
           }
diff --git a/http2/hpack/decoder/hpack_string_decoder_listener.cc b/http2/hpack/decoder/hpack_string_decoder_listener.cc
index e0fbc65..7a132e4 100644
--- a/http2/hpack/decoder/hpack_string_decoder_listener.cc
+++ b/http2/hpack/decoder/hpack_string_decoder_listener.cc
@@ -4,14 +4,14 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_decoder_listener.h"
 
-#include "base/logging.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 
 namespace http2 {
 namespace test {
 
 void HpackStringDecoderVLoggingListener::OnStringStart(bool huffman_encoded,
                                                        size_t len) {
-  VLOG(1) << "OnStringStart: H=" << huffman_encoded << ", len=" << len;
+  HTTP2_VLOG(1) << "OnStringStart: H=" << huffman_encoded << ", len=" << len;
   if (wrapped_) {
     wrapped_->OnStringStart(huffman_encoded, len);
   }
@@ -19,14 +19,14 @@
 
 void HpackStringDecoderVLoggingListener::OnStringData(const char* data,
                                                       size_t len) {
-  VLOG(1) << "OnStringData: len=" << len;
+  HTTP2_VLOG(1) << "OnStringData: len=" << len;
   if (wrapped_) {
     return wrapped_->OnStringData(data, len);
   }
 }
 
 void HpackStringDecoderVLoggingListener::OnStringEnd() {
-  VLOG(1) << "OnStringEnd";
+  HTTP2_VLOG(1) << "OnStringEnd";
   if (wrapped_) {
     return wrapped_->OnStringEnd();
   }
diff --git a/http2/hpack/decoder/hpack_string_decoder_test.cc b/http2/hpack/decoder/hpack_string_decoder_test.cc
index 349b649..5346999 100644
--- a/http2/hpack/decoder/hpack_string_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_string_decoder_test.cc
@@ -38,13 +38,13 @@
   DecodeStatus ResumeDecoding(DecodeBuffer* b) override {
     // Provides coverage of DebugString and StateToString.
     // Not validating output.
-    VLOG(1) << decoder_.DebugString();
-    VLOG(2) << collector_;
+    HTTP2_VLOG(1) << decoder_.DebugString();
+    HTTP2_VLOG(2) << collector_;
     return decoder_.Resume(b, &listener_);
   }
 
   AssertionResult Collected(Http2StringPiece s, bool huffman_encoded) {
-    VLOG(1) << collector_;
+    HTTP2_VLOG(1) << collector_;
     return collector_.Collected(s, huffman_encoded);
   }
 
@@ -64,9 +64,9 @@
             VERIFY_NE(collector_,
                       HpackStringCollector(expected_str, expected_huffman));
           }
-          VLOG(2) << collector_.ToString();
+          HTTP2_VLOG(2) << collector_.ToString();
           collector_.Clear();
-          VLOG(2) << collector_;
+          HTTP2_VLOG(2) << collector_;
           return result;
         };
   }
diff --git a/http2/hpack/decoder/hpack_whole_entry_buffer.cc b/http2/hpack/decoder/hpack_whole_entry_buffer.cc
index b3e29b1..dea6698 100644
--- a/http2/hpack/decoder/hpack_whole_entry_buffer.cc
+++ b/http2/hpack/decoder/hpack_whole_entry_buffer.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_whole_entry_buffer.h"
 
-#include "base/logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_estimate_memory_usage.h"
+#include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_macros.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 
@@ -37,26 +37,26 @@
 }
 
 void HpackWholeEntryBuffer::OnIndexedHeader(size_t index) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnIndexedHeader: index=" << index;
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnIndexedHeader: index=" << index;
   listener_->OnIndexedHeader(index);
 }
 
 void HpackWholeEntryBuffer::OnStartLiteralHeader(HpackEntryType entry_type,
                                                  size_t maybe_name_index) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnStartLiteralHeader: entry_type="
-           << entry_type << ",  maybe_name_index=" << maybe_name_index;
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnStartLiteralHeader: entry_type="
+                 << entry_type << ",  maybe_name_index=" << maybe_name_index;
   entry_type_ = entry_type;
   maybe_name_index_ = maybe_name_index;
 }
 
 void HpackWholeEntryBuffer::OnNameStart(bool huffman_encoded, size_t len) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnNameStart: huffman_encoded="
-           << (huffman_encoded ? "true" : "false") << ",  len=" << len;
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnNameStart: huffman_encoded="
+                 << (huffman_encoded ? "true" : "false") << ",  len=" << len;
   DCHECK_EQ(maybe_name_index_, 0u);
   if (!error_detected_) {
     if (len > max_string_size_bytes_) {
-      DVLOG(1) << "Name length (" << len << ") is longer than permitted ("
-               << max_string_size_bytes_ << ")";
+      HTTP2_DVLOG(1) << "Name length (" << len << ") is longer than permitted ("
+                     << max_string_size_bytes_ << ")";
       ReportError("HPACK entry name size is too long.");
       return;
     }
@@ -65,8 +65,9 @@
 }
 
 void HpackWholeEntryBuffer::OnNameData(const char* data, size_t len) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnNameData: len=" << len << " data:\n"
-           << Http2HexDump(Http2StringPiece(data, len));
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnNameData: len=" << len
+                 << " data:\n"
+                 << Http2HexDump(Http2StringPiece(data, len));
   DCHECK_EQ(maybe_name_index_, 0u);
   if (!error_detected_ && !name_.OnData(data, len)) {
     ReportError("Error decoding HPACK entry name.");
@@ -74,7 +75,7 @@
 }
 
 void HpackWholeEntryBuffer::OnNameEnd() {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnNameEnd";
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnNameEnd";
   DCHECK_EQ(maybe_name_index_, 0u);
   if (!error_detected_ && !name_.OnEnd()) {
     ReportError("Error decoding HPACK entry name.");
@@ -82,12 +83,13 @@
 }
 
 void HpackWholeEntryBuffer::OnValueStart(bool huffman_encoded, size_t len) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnValueStart: huffman_encoded="
-           << (huffman_encoded ? "true" : "false") << ",  len=" << len;
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnValueStart: huffman_encoded="
+                 << (huffman_encoded ? "true" : "false") << ",  len=" << len;
   if (!error_detected_) {
     if (len > max_string_size_bytes_) {
-      DVLOG(1) << "Value length (" << len << ") is longer than permitted ("
-               << max_string_size_bytes_ << ")";
+      HTTP2_DVLOG(1) << "Value length (" << len
+                     << ") is longer than permitted (" << max_string_size_bytes_
+                     << ")";
       ReportError("HPACK entry value size is too long.");
       return;
     }
@@ -96,15 +98,16 @@
 }
 
 void HpackWholeEntryBuffer::OnValueData(const char* data, size_t len) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnValueData: len=" << len << " data:\n"
-           << Http2HexDump(Http2StringPiece(data, len));
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnValueData: len=" << len
+                 << " data:\n"
+                 << Http2HexDump(Http2StringPiece(data, len));
   if (!error_detected_ && !value_.OnData(data, len)) {
     ReportError("Error decoding HPACK entry value.");
   }
 }
 
 void HpackWholeEntryBuffer::OnValueEnd() {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnValueEnd";
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnValueEnd";
   if (error_detected_) {
     return;
   }
@@ -123,13 +126,14 @@
 }
 
 void HpackWholeEntryBuffer::OnDynamicTableSizeUpdate(size_t size) {
-  DVLOG(2) << "HpackWholeEntryBuffer::OnDynamicTableSizeUpdate: size=" << size;
+  HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnDynamicTableSizeUpdate: size="
+                 << size;
   listener_->OnDynamicTableSizeUpdate(size);
 }
 
 void HpackWholeEntryBuffer::ReportError(Http2StringPiece error_message) {
   if (!error_detected_) {
-    DVLOG(1) << "HpackWholeEntryBuffer::ReportError: " << error_message;
+    HTTP2_DVLOG(1) << "HpackWholeEntryBuffer::ReportError: " << error_message;
     error_detected_ = true;
     listener_->OnHpackDecodeError(error_message);
     listener_ = HpackWholeEntryNoOpListener::NoOpListener();