diff --git a/spdy/core/fifo_write_scheduler.h b/spdy/core/fifo_write_scheduler.h
index bd2cfec..fd2c85e 100644
--- a/spdy/core/fifo_write_scheduler.h
+++ b/spdy/core/fifo_write_scheduler.h
@@ -67,8 +67,7 @@
     StreamIdType stream_id,
     const StreamPrecedenceType& precedence) {
   if (StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_36_1)
-        << "Stream " << stream_id << " already registered";
+    SPDY_BUG(spdy_bug_36_1) << "Stream " << stream_id << " already registered";
     return;
   }
   registered_streams_.emplace_hint(
@@ -80,8 +79,7 @@
 void FifoWriteScheduler<StreamIdType>::UnregisterStream(
     StreamIdType stream_id) {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_36_2)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_36_2) << "Stream " << stream_id << " is not registered";
     return;
   }
   registered_streams_.erase(stream_id);
@@ -133,8 +131,7 @@
   if (it != registered_streams_.end()) {
     it->second.event_time = now_in_usec;
   } else {
-    SPDY_BUG_V2(spdy_bug_36_3)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_36_3) << "Stream " << stream_id << " is not registered";
   }
 }
 
@@ -142,8 +139,7 @@
 int64_t FifoWriteScheduler<StreamIdType>::GetLatestEventWithPrecedence(
     StreamIdType stream_id) const {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_36_4)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_36_4) << "Stream " << stream_id << " is not registered";
     return 0;
   }
   int64_t latest_event_time_us = 0;
@@ -168,8 +164,7 @@
 void FifoWriteScheduler<StreamIdType>::MarkStreamReady(StreamIdType stream_id,
                                                        bool /*add_to_front*/) {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_36_5)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_36_5) << "Stream " << stream_id << " is not registered";
     return;
   }
   if (ready_streams_.find(stream_id) != ready_streams_.end()) {
@@ -198,7 +193,7 @@
 template <typename StreamIdType>
 StreamIdType FifoWriteScheduler<StreamIdType>::PopNextReadyStream() {
   if (ready_streams_.empty()) {
-    SPDY_BUG_V2(spdy_bug_36_6) << "No ready streams available";
+    SPDY_BUG(spdy_bug_36_6) << "No ready streams available";
     return 0;
   }
   auto it = ready_streams_.begin();
@@ -224,8 +219,7 @@
 bool FifoWriteScheduler<StreamIdType>::IsStreamReady(
     StreamIdType stream_id) const {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_36_7)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_36_7) << "Stream " << stream_id << " is not registered";
     return false;
   }
   return ready_streams_.find(stream_id) != ready_streams_.end();
diff --git a/spdy/core/http2_frame_decoder_adapter.cc b/spdy/core/http2_frame_decoder_adapter.cc
index c41f258..cb9c176 100644
--- a/spdy/core/http2_frame_decoder_adapter.cc
+++ b/spdy/core/http2_frame_decoder_adapter.cc
@@ -470,7 +470,7 @@
   on_headers_called_ = true;
   ReportReceiveCompressedFrame(frame_header_);
   if (!visitor()) {
-    SPDY_BUG_V2(spdy_bug_1_1)
+    SPDY_BUG(spdy_bug_1_1)
         << "Visitor is nullptr, handling priority in headers failed."
         << " priority:" << priority << " frame_header:" << frame_header_;
     return;
@@ -822,7 +822,7 @@
                      << " total remaining in the frame's payload.";
         db.AdvanceCursor(avail);
       } else {
-        SPDY_BUG_V2(spdy_bug_1_2)
+        SPDY_BUG(spdy_bug_1_2)
             << "Total remaining (" << total
             << ") should not be greater than the payload length; "
             << frame_header();
@@ -873,11 +873,11 @@
           DecodeBuffer tmp("", 0);
           DecodeStatus status = frame_decoder_->DecodeFrame(&tmp);
           if (status != DecodeStatus::kDecodeDone) {
-            SPDY_BUG_V2(spdy_bug_1_3)
+            SPDY_BUG(spdy_bug_1_3)
                 << "Expected to be done decoding the frame, not " << status;
             SetSpdyErrorAndNotify(SPDY_INTERNAL_FRAMER_ERROR, "");
           } else if (spdy_framer_error_ != SPDY_NO_ERROR) {
-            SPDY_BUG_V2(spdy_bug_1_4)
+            SPDY_BUG(spdy_bug_1_4)
                 << "Expected to have no error, not "
                 << SpdyFramerErrorToString(spdy_framer_error_);
           } else {
@@ -1074,8 +1074,7 @@
   SpdyHeadersHandlerInterface* handler =
       visitor()->OnHeaderFrameStart(stream_id());
   if (handler == nullptr) {
-    SPDY_BUG_V2(spdy_bug_1_5)
-        << "visitor_->OnHeaderFrameStart returned nullptr";
+    SPDY_BUG(spdy_bug_1_5) << "visitor_->OnHeaderFrameStart returned nullptr";
     SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INTERNAL_FRAMER_ERROR, "");
     return;
   }
diff --git a/spdy/core/http2_priority_write_scheduler.h b/spdy/core/http2_priority_write_scheduler.h
index dbfa005..edd6783 100644
--- a/spdy/core/http2_priority_write_scheduler.h
+++ b/spdy/core/http2_priority_write_scheduler.h
@@ -221,12 +221,11 @@
   //   (e.g. SpdyClientDispatcher) modified to pass StreamPrecedence instances
   //   appropriate for protocol version under test.
   //
-  // SPDY_BUG_IF_V2(spdy_bug_8_1, precedence.is_spdy3_priority())
+  // SPDY_BUG_IF(spdy_bug_8_1, precedence.is_spdy3_priority())
   //     << "Expected HTTP/2 stream dependency";
 
   if (StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_8_2)
-        << "Stream " << stream_id << " already registered";
+    SPDY_BUG(spdy_bug_8_2) << "Stream " << stream_id << " already registered";
     return;
   }
 
@@ -273,13 +272,13 @@
 void Http2PriorityWriteScheduler<StreamIdType>::UnregisterStream(
     StreamIdType stream_id) {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_3) << "Cannot unregister root stream";
+    SPDY_BUG(spdy_bug_8_3) << "Cannot unregister root stream";
     return;
   }
   // Remove the stream from table.
   auto it = all_stream_infos_.find(stream_id);
   if (it == all_stream_infos_.end()) {
-    SPDY_BUG_V2(spdy_bug_8_4) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_4) << "Stream " << stream_id << " not registered";
     return;
   }
   std::unique_ptr<StreamInfo> stream_info(std::move(it->second));
@@ -336,7 +335,7 @@
   std::vector<StreamIdType> child_vec;
   const StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_5) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_5) << "Stream " << stream_id << " not registered";
   } else {
     child_vec.reserve(stream_info->children.size());
     for (StreamInfo* child : stream_info->children) {
@@ -354,10 +353,10 @@
   //   (e.g. SpdyClientDispatcher) modified to pass StreamPrecedence instances
   //   appropriate for protocol version under test.
   //
-  // SPDY_BUG_IF_V2(spdy_bug_8_6, precedence.is_spdy3_priority())
+  // SPDY_BUG_IF(spdy_bug_8_6, precedence.is_spdy3_priority())
   //     << "Expected HTTP/2 stream dependency";
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_7) << "Cannot set precedence of root stream";
+    SPDY_BUG(spdy_bug_8_7) << "Cannot set precedence of root stream";
     return;
   }
 
@@ -394,7 +393,7 @@
     StreamIdType parent_id,
     bool exclusive) {
   if (stream_info->id == parent_id) {
-    SPDY_BUG_V2(spdy_bug_8_8) << "Cannot set stream to be its own parent";
+    SPDY_BUG(spdy_bug_8_8) << "Cannot set stream to be its own parent";
     return;
   }
   StreamInfo* new_parent = FindStream(parent_id);
@@ -458,12 +457,12 @@
     StreamIdType stream_id,
     int64_t now_in_usec) {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_9) << "Cannot record event time for root stream";
+    SPDY_BUG(spdy_bug_8_9) << "Cannot record event time for root stream";
     return;
   }
   StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_10) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_10) << "Stream " << stream_id << " not registered";
     return;
   }
   stream_info->last_event_time_usec = now_in_usec;
@@ -478,12 +477,12 @@
 int64_t Http2PriorityWriteScheduler<StreamIdType>::GetLatestEventWithPrecedence(
     StreamIdType stream_id) const {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_11) << "Invalid argument: root stream";
+    SPDY_BUG(spdy_bug_8_11) << "Invalid argument: root stream";
     return 0;
   }
   const StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_12) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_12) << "Stream " << stream_id << " not registered";
     return 0;
   }
   int64_t last_event_time_usec = 0;
@@ -504,12 +503,12 @@
 bool Http2PriorityWriteScheduler<StreamIdType>::ShouldYield(
     StreamIdType stream_id) const {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_13) << "Invalid argument: root stream";
+    SPDY_BUG(spdy_bug_8_13) << "Invalid argument: root stream";
     return false;
   }
   const StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_14) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_14) << "Stream " << stream_id << " not registered";
     return false;
   }
   if (HasReadyAncestor(*stream_info)) {
@@ -535,12 +534,12 @@
     StreamIdType stream_id,
     bool add_to_front) {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_15) << "Cannot mark root stream ready";
+    SPDY_BUG(spdy_bug_8_15) << "Cannot mark root stream ready";
     return;
   }
   StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_16) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_16) << "Stream " << stream_id << " not registered";
     return;
   }
   if (stream_info->ready) {
@@ -554,12 +553,12 @@
 void Http2PriorityWriteScheduler<StreamIdType>::MarkStreamNotReady(
     StreamIdType stream_id) {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_17) << "Cannot mark root stream unready";
+    SPDY_BUG(spdy_bug_8_17) << "Cannot mark root stream unready";
     return;
   }
   StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_18) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_18) << "Stream " << stream_id << " not registered";
     return;
   }
   if (!stream_info->ready) {
@@ -681,7 +680,7 @@
       return std::make_tuple(stream_info.id, stream_info.ToStreamPrecedence());
     }
   }
-  SPDY_BUG_V2(spdy_bug_8_19) << "No ready streams";
+  SPDY_BUG(spdy_bug_8_19) << "No ready streams";
   return std::make_tuple(
       kHttp2RootStreamId,
       StreamPrecedenceType(kHttp2RootStreamId, kHttp2MinStreamWeight, false));
@@ -696,12 +695,12 @@
 bool Http2PriorityWriteScheduler<StreamIdType>::IsStreamReady(
     StreamIdType stream_id) const {
   if (stream_id == kHttp2RootStreamId) {
-    SPDY_BUG_V2(spdy_bug_8_20) << "Try to check whether root stream is ready";
+    SPDY_BUG(spdy_bug_8_20) << "Try to check whether root stream is ready";
     return false;
   }
   const StreamInfo* stream_info = FindStream(stream_id);
   if (stream_info == nullptr) {
-    SPDY_BUG_V2(spdy_bug_8_21) << "Stream " << stream_id << " not registered";
+    SPDY_BUG(spdy_bug_8_21) << "Stream " << stream_id << " not registered";
     return false;
   }
   return stream_info->ready;
diff --git a/spdy/core/lifo_write_scheduler.h b/spdy/core/lifo_write_scheduler.h
index 1f13b88..a5aa0b5 100644
--- a/spdy/core/lifo_write_scheduler.h
+++ b/spdy/core/lifo_write_scheduler.h
@@ -98,8 +98,7 @@
     StreamIdType stream_id,
     const StreamPrecedenceType& precedence) {
   if (StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_13_1)
-        << "Stream " << stream_id << " already registered";
+    SPDY_BUG(spdy_bug_13_1) << "Stream " << stream_id << " already registered";
     return;
   }
   registered_streams_.emplace_hint(
@@ -111,8 +110,7 @@
 void LifoWriteScheduler<StreamIdType>::UnregisterStream(
     StreamIdType stream_id) {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_13_2)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_13_2) << "Stream " << stream_id << " is not registered";
     return;
   }
   registered_streams_.erase(stream_id);
@@ -151,8 +149,7 @@
   if (it != registered_streams_.end()) {
     it->second.event_time = now_in_usec;
   } else {
-    SPDY_BUG_V2(spdy_bug_13_3)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_13_3) << "Stream " << stream_id << " is not registered";
   }
 }
 
@@ -160,8 +157,7 @@
 int64_t LifoWriteScheduler<StreamIdType>::GetLatestEventWithPrecedence(
     StreamIdType stream_id) const {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_13_4)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_13_4) << "Stream " << stream_id << " is not registered";
     return 0;
   }
   int64_t latest_event_time_us = 0;
@@ -181,7 +177,7 @@
 template <typename StreamIdType>
 StreamIdType LifoWriteScheduler<StreamIdType>::PopNextReadyStream() {
   if (ready_streams_.empty()) {
-    SPDY_BUG_V2(spdy_bug_13_5) << "No ready streams available";
+    SPDY_BUG(spdy_bug_13_5) << "No ready streams available";
     return 0;
   }
   auto it = --ready_streams_.end();
@@ -194,8 +190,7 @@
 void LifoWriteScheduler<StreamIdType>::MarkStreamReady(StreamIdType stream_id,
                                                        bool /*add_to_front*/) {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_13_6)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_13_6) << "Stream " << stream_id << " is not registered";
     return;
   }
   if (ready_streams_.find(stream_id) != ready_streams_.end()) {
@@ -220,8 +215,7 @@
 bool LifoWriteScheduler<StreamIdType>::IsStreamReady(
     StreamIdType stream_id) const {
   if (!StreamRegistered(stream_id)) {
-    SPDY_BUG_V2(spdy_bug_13_7)
-        << "Stream " << stream_id << " is not registered";
+    SPDY_BUG(spdy_bug_13_7) << "Stream " << stream_id << " is not registered";
     return false;
   }
   return ready_streams_.find(stream_id) != ready_streams_.end();
diff --git a/spdy/core/priority_write_scheduler.h b/spdy/core/priority_write_scheduler.h
index 1f7ed15..89e3441 100644
--- a/spdy/core/priority_write_scheduler.h
+++ b/spdy/core/priority_write_scheduler.h
@@ -61,21 +61,21 @@
         << "Parent stream " << parent_id << " not registered";
 
     if (stream_id == root_stream_id_) {
-      SPDY_BUG_V2(spdy_bug_19_1)
+      SPDY_BUG(spdy_bug_19_1)
           << "Stream " << root_stream_id_ << " already registered";
       return;
     }
     StreamInfo stream_info = {precedence.spdy3_priority(), stream_id, false};
     bool inserted =
         stream_infos_.insert(std::make_pair(stream_id, stream_info)).second;
-    SPDY_BUG_IF_V2(spdy_bug_19_2, !inserted)
+    SPDY_BUG_IF(spdy_bug_19_2, !inserted)
         << "Stream " << stream_id << " already registered";
   }
 
   void UnregisterStream(StreamIdType stream_id) override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_3) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_3) << "Stream " << stream_id << " not registered";
       return;
     }
     StreamInfo& stream_info = it->second;
@@ -143,7 +143,7 @@
                              int64_t now_in_usec) override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_4) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_4) << "Stream " << stream_id << " not registered";
       return;
     }
     PriorityInfo& priority_info = priority_infos_[it->second.priority];
@@ -154,7 +154,7 @@
   int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_5) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_5) << "Stream " << stream_id << " not registered";
       return 0;
     }
     int64_t last_event_time_usec = 0;
@@ -187,14 +187,14 @@
                                StreamPrecedenceType(info->priority));
       }
     }
-    SPDY_BUG_V2(spdy_bug_19_6) << "No ready streams available";
+    SPDY_BUG(spdy_bug_19_6) << "No ready streams available";
     return std::make_tuple(0, StreamPrecedenceType(kV3LowestPriority));
   }
 
   bool ShouldYield(StreamIdType stream_id) const override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_7) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_7) << "Stream " << stream_id << " not registered";
       return false;
     }
 
@@ -221,7 +221,7 @@
   void MarkStreamReady(StreamIdType stream_id, bool add_to_front) override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_8) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_8) << "Stream " << stream_id << " not registered";
       return;
     }
     StreamInfo& stream_info = it->second;
@@ -241,7 +241,7 @@
   void MarkStreamNotReady(StreamIdType stream_id) override {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
-      SPDY_BUG_V2(spdy_bug_19_9) << "Stream " << stream_id << " not registered";
+      SPDY_BUG(spdy_bug_19_9) << "Stream " << stream_id << " not registered";
       return;
     }
     StreamInfo& stream_info = it->second;
diff --git a/spdy/core/spdy_frame_builder.cc b/spdy/core/spdy_frame_builder.cc
index 89db2d9..ee63594 100644
--- a/spdy/core/spdy_frame_builder.cc
+++ b/spdy/core/spdy_frame_builder.cc
@@ -69,7 +69,7 @@
   QUICHE_DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   bool success = true;
   if (length_ > 0) {
-    SPDY_BUG_V2(spdy_bug_73_1)
+    SPDY_BUG(spdy_bug_73_1)
         << "SpdyFrameBuilder doesn't have a clean state when BeginNewFrame"
         << "is called. Leftover length_ is " << length_;
     offset_ += length_;
@@ -91,7 +91,7 @@
   uint8_t raw_frame_type = SerializeFrameType(type);
   QUICHE_DCHECK(IsDefinedFrameType(raw_frame_type));
   QUICHE_DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
-  SPDY_BUG_IF_V2(spdy_bug_73_2, length > kHttp2DefaultFramePayloadLimit)
+  SPDY_BUG_IF(spdy_bug_73_2, length > kHttp2DefaultFramePayloadLimit)
       << "Frame length  " << length_ << " is longer than frame size limit.";
   return BeginNewFrameInternal(raw_frame_type, flags, stream_id, length);
 }
diff --git a/spdy/core/spdy_frame_builder.h b/spdy/core/spdy_frame_builder.h
index 3ed8ef0..01fce6b 100644
--- a/spdy/core/spdy_frame_builder.h
+++ b/spdy/core/spdy_frame_builder.h
@@ -66,10 +66,10 @@
 
   // Takes the buffer from the SpdyFrameBuilder.
   SpdySerializedFrame take() {
-    SPDY_BUG_IF_V2(spdy_bug_39_1, output_ != nullptr)
+    SPDY_BUG_IF(spdy_bug_39_1, output_ != nullptr)
         << "ZeroCopyOutputBuffer is used to build "
         << "frames. take() shouldn't be called";
-    SPDY_BUG_IF_V2(spdy_bug_39_2, kMaxFrameSizeLimit < length_)
+    SPDY_BUG_IF(spdy_bug_39_2, kMaxFrameSizeLimit < length_)
         << "Frame length " << length_
         << " is longer than the maximum possible allowed length.";
     SpdySerializedFrame rv(buffer_.release(), length(), true);
diff --git a/spdy/core/spdy_framer.cc b/spdy/core/spdy_framer.cc
index 68cda07..19e53b6 100644
--- a/spdy/core/spdy_framer.cc
+++ b/spdy/core/spdy_framer.cc
@@ -294,7 +294,7 @@
 size_t SpdyFramer::SpdyFrameIterator::NextFrame(ZeroCopyOutputBuffer* output) {
   const SpdyFrameIR& frame_ir = GetIR();
   if (!has_next_frame_) {
-    SPDY_BUG_V2(spdy_bug_75_1)
+    SPDY_BUG(spdy_bug_75_1)
         << "SpdyFramer::SpdyFrameIterator::NextFrame called without "
         << "a next frame.";
     return false;
diff --git a/spdy/core/spdy_protocol.cc b/spdy/core/spdy_protocol.cc
index ac51958..4839b9b 100644
--- a/spdy/core/spdy_protocol.cc
+++ b/spdy/core/spdy_protocol.cc
@@ -29,7 +29,7 @@
                 "The value of given priority shouldn't be smaller than highest "
                 "priority. Check this invariant explicitly.");
   if (priority > kV3LowestPriority) {
-    SPDY_BUG_V2(spdy_bug_22_1)
+    SPDY_BUG(spdy_bug_22_1)
         << "Invalid priority: " << static_cast<int>(priority);
     return kV3LowestPriority;
   }
@@ -38,11 +38,11 @@
 
 int ClampHttp2Weight(int weight) {
   if (weight < kHttp2MinStreamWeight) {
-    SPDY_BUG_V2(spdy_bug_22_2) << "Invalid weight: " << weight;
+    SPDY_BUG(spdy_bug_22_2) << "Invalid weight: " << weight;
     return kHttp2MinStreamWeight;
   }
   if (weight > kHttp2MaxStreamWeight) {
-    SPDY_BUG_V2(spdy_bug_22_3) << "Invalid weight: " << weight;
+    SPDY_BUG(spdy_bug_22_3) << "Invalid weight: " << weight;
     return kHttp2MaxStreamWeight;
   }
   return weight;
@@ -93,7 +93,7 @@
 }
 
 SpdyFrameType ParseFrameType(uint8_t frame_type_field) {
-  SPDY_BUG_IF_V2(spdy_bug_22_4, !IsDefinedFrameType(frame_type_field))
+  SPDY_BUG_IF(spdy_bug_22_4, !IsDefinedFrameType(frame_type_field))
       << "Frame type not defined: " << static_cast<int>(frame_type_field);
   return static_cast<SpdyFrameType>(frame_type_field);
 }