diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 2e8b80f..89d06d4 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -2828,13 +2828,10 @@
 
   QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0, data);
 
-  EXPECT_CALL(
-      *connection_,
-      CloseConnection(
-          GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-              ? QUIC_QPACK_ENCODER_STREAM_DUPLICATE_INVALID_RELATIVE_INDEX
-              : QUIC_QPACK_ENCODER_STREAM_ERROR,
-          "Encoder stream error: Invalid relative index.", _));
+  EXPECT_CALL(*connection_,
+              CloseConnection(
+                  QUIC_QPACK_ENCODER_STREAM_DUPLICATE_INVALID_RELATIVE_INDEX,
+                  "Encoder stream error: Invalid relative index.", _));
   session_.OnStreamFrame(frame);
 }
 
@@ -2854,9 +2851,7 @@
 
   EXPECT_CALL(
       *connection_,
-      CloseConnection(GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                          ? QUIC_QPACK_DECODER_STREAM_INVALID_ZERO_INCREMENT
-                          : QUIC_QPACK_DECODER_STREAM_ERROR,
+      CloseConnection(QUIC_QPACK_DECODER_STREAM_INVALID_ZERO_INCREMENT,
                       "Decoder stream error: Invalid increment value 0.", _));
   session_.OnStreamFrame(frame);
 }
diff --git a/quic/core/qpack/qpack_decoder.cc b/quic/core/qpack/qpack_decoder.cc
index 6ba9608..35c64a0 100644
--- a/quic/core/qpack/qpack_decoder.cc
+++ b/quic/core/qpack/qpack_decoder.cc
@@ -154,14 +154,8 @@
 
 void QpackDecoder::OnErrorDetected(QuicErrorCode error_code,
                                    absl::string_view error_message) {
-  if (GetQuicReloadableFlag(quic_granular_qpack_error_codes)) {
-    QUIC_CODE_COUNT_N(quic_granular_qpack_error_codes, 2, 2);
-    encoder_stream_error_delegate_->OnEncoderStreamError(error_code,
-                                                         error_message);
-  } else {
-    encoder_stream_error_delegate_->OnEncoderStreamError(
-        QUIC_QPACK_ENCODER_STREAM_ERROR, error_message);
-  }
+  encoder_stream_error_delegate_->OnEncoderStreamError(error_code,
+                                                       error_message);
 }
 
 std::unique_ptr<QpackProgressiveDecoder> QpackDecoder::CreateProgressiveDecoder(
diff --git a/quic/core/qpack/qpack_decoder_test.cc b/quic/core/qpack/qpack_decoder_test.cc
index 4aa4d82..3b57ca6 100644
--- a/quic/core/qpack/qpack_decoder_test.cc
+++ b/quic/core/qpack/qpack_decoder_test.cc
@@ -440,12 +440,10 @@
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorEntryTooLarge) {
-  EXPECT_CALL(encoder_stream_error_delegate_,
-              OnEncoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_ENCODER_STREAM_ERROR_INSERTING_LITERAL
-                      : QUIC_QPACK_ENCODER_STREAM_ERROR,
-                  Eq("Error inserting literal entry.")));
+  EXPECT_CALL(
+      encoder_stream_error_delegate_,
+      OnEncoderStreamError(QUIC_QPACK_ENCODER_STREAM_ERROR_INSERTING_LITERAL,
+                           Eq("Error inserting literal entry.")));
 
   // Set dynamic table capacity to 34.
   DecodeEncoderStreamData(absl::HexStringToBytes("3f03"));
@@ -454,25 +452,20 @@
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidStaticTableEntry) {
-  EXPECT_CALL(encoder_stream_error_delegate_,
-              OnEncoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_ENCODER_STREAM_INVALID_STATIC_ENTRY
-                      : QUIC_QPACK_ENCODER_STREAM_ERROR,
-                  Eq("Invalid static table entry.")));
+  EXPECT_CALL(
+      encoder_stream_error_delegate_,
+      OnEncoderStreamError(QUIC_QPACK_ENCODER_STREAM_INVALID_STATIC_ENTRY,
+                           Eq("Invalid static table entry.")));
 
   // Address invalid static table entry index 99.
   DecodeEncoderStreamData(absl::HexStringToBytes("ff2400"));
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidDynamicTableEntry) {
-  EXPECT_CALL(
-      encoder_stream_error_delegate_,
-      OnEncoderStreamError(
-          GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-              ? QUIC_QPACK_ENCODER_STREAM_INSERTION_INVALID_RELATIVE_INDEX
-              : QUIC_QPACK_ENCODER_STREAM_ERROR,
-          Eq("Invalid relative index.")));
+  EXPECT_CALL(encoder_stream_error_delegate_,
+              OnEncoderStreamError(
+                  QUIC_QPACK_ENCODER_STREAM_INSERTION_INVALID_RELATIVE_INDEX,
+                  Eq("Invalid relative index.")));
 
   DecodeEncoderStreamData(absl::HexStringToBytes(
       "3fe107"          // Set dynamic table capacity to 1024.
@@ -483,13 +476,10 @@
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorDuplicateInvalidEntry) {
-  EXPECT_CALL(
-      encoder_stream_error_delegate_,
-      OnEncoderStreamError(
-          GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-              ? QUIC_QPACK_ENCODER_STREAM_DUPLICATE_INVALID_RELATIVE_INDEX
-              : QUIC_QPACK_ENCODER_STREAM_ERROR,
-          Eq("Invalid relative index.")));
+  EXPECT_CALL(encoder_stream_error_delegate_,
+              OnEncoderStreamError(
+                  QUIC_QPACK_ENCODER_STREAM_DUPLICATE_INVALID_RELATIVE_INDEX,
+                  Eq("Invalid relative index.")));
 
   DecodeEncoderStreamData(absl::HexStringToBytes(
       "3fe107"          // Set dynamic table capacity to 1024.
@@ -501,11 +491,8 @@
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorTooLargeInteger) {
   EXPECT_CALL(encoder_stream_error_delegate_,
-              OnEncoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE
-                      : QUIC_QPACK_ENCODER_STREAM_ERROR,
-                  Eq("Encoded integer too large.")));
+              OnEncoderStreamError(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
+                                   Eq("Encoded integer too large.")));
 
   DecodeEncoderStreamData(absl::HexStringToBytes("3fffffffffffffffffffff"));
 }
@@ -608,12 +595,10 @@
 }
 
 TEST_P(QpackDecoderTest, TableCapacityMustNotExceedMaximum) {
-  EXPECT_CALL(encoder_stream_error_delegate_,
-              OnEncoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_ENCODER_STREAM_SET_DYNAMIC_TABLE_CAPACITY
-                      : QUIC_QPACK_ENCODER_STREAM_ERROR,
-                  Eq("Error updating dynamic table capacity.")));
+  EXPECT_CALL(
+      encoder_stream_error_delegate_,
+      OnEncoderStreamError(QUIC_QPACK_ENCODER_STREAM_SET_DYNAMIC_TABLE_CAPACITY,
+                           Eq("Error updating dynamic table capacity.")));
 
   // Try to update dynamic table capacity to 2048, which exceeds the maximum.
   DecodeEncoderStreamData(absl::HexStringToBytes("3fe10f"));
diff --git a/quic/core/qpack/qpack_encoder.cc b/quic/core/qpack/qpack_encoder.cc
index 7fc128f..6ad432b 100644
--- a/quic/core/qpack/qpack_encoder.cc
+++ b/quic/core/qpack/qpack_encoder.cc
@@ -441,14 +441,8 @@
 
 void QpackEncoder::OnErrorDetected(QuicErrorCode error_code,
                                    absl::string_view error_message) {
-  if (GetQuicReloadableFlag(quic_granular_qpack_error_codes)) {
-    QUIC_CODE_COUNT_N(quic_granular_qpack_error_codes, 1, 2);
-    decoder_stream_error_delegate_->OnDecoderStreamError(error_code,
-                                                         error_message);
-  } else {
-    decoder_stream_error_delegate_->OnDecoderStreamError(
-        QUIC_QPACK_DECODER_STREAM_ERROR, error_message);
-  }
+  decoder_stream_error_delegate_->OnDecoderStreamError(error_code,
+                                                       error_message);
 }
 
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_encoder_test.cc b/quic/core/qpack/qpack_encoder_test.cc
index 0a1d739..5045c8f 100644
--- a/quic/core/qpack/qpack_encoder_test.cc
+++ b/quic/core/qpack/qpack_encoder_test.cc
@@ -141,11 +141,8 @@
 
 TEST_F(QpackEncoderTest, DecoderStreamError) {
   EXPECT_CALL(decoder_stream_error_delegate_,
-              OnDecoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE
-                      : QUIC_QPACK_DECODER_STREAM_ERROR,
-                  Eq("Encoded integer too large.")));
+              OnDecoderStreamError(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
+                                   Eq("Encoded integer too large.")));
 
   QpackEncoder encoder(&decoder_stream_error_delegate_);
   encoder.set_qpack_stream_sender_delegate(&encoder_stream_sender_delegate_);
@@ -168,12 +165,10 @@
 
 TEST_F(QpackEncoderTest, ZeroInsertCountIncrement) {
   // Encoder receives insert count increment with forbidden value 0.
-  EXPECT_CALL(decoder_stream_error_delegate_,
-              OnDecoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_DECODER_STREAM_INVALID_ZERO_INCREMENT
-                      : QUIC_QPACK_DECODER_STREAM_ERROR,
-                  Eq("Invalid increment value 0.")));
+  EXPECT_CALL(
+      decoder_stream_error_delegate_,
+      OnDecoderStreamError(QUIC_QPACK_DECODER_STREAM_INVALID_ZERO_INCREMENT,
+                           Eq("Invalid increment value 0.")));
   encoder_.OnInsertCountIncrement(0);
 }
 
@@ -181,13 +176,11 @@
   // Encoder receives insert count increment with value that increases Known
   // Received Count to a value (one) which is larger than the number of dynamic
   // table insertions sent (zero).
-  EXPECT_CALL(decoder_stream_error_delegate_,
-              OnDecoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_DECODER_STREAM_IMPOSSIBLE_INSERT_COUNT
-                      : QUIC_QPACK_DECODER_STREAM_ERROR,
-                  Eq("Increment value 1 raises known received count "
-                     "to 1 exceeding inserted entry count 0")));
+  EXPECT_CALL(
+      decoder_stream_error_delegate_,
+      OnDecoderStreamError(QUIC_QPACK_DECODER_STREAM_IMPOSSIBLE_INSERT_COUNT,
+                           Eq("Increment value 1 raises known received count "
+                              "to 1 exceeding inserted entry count 0")));
   encoder_.OnInsertCountIncrement(1);
 }
 
@@ -208,9 +201,7 @@
   // received count.  This must result in an error instead of a crash.
   EXPECT_CALL(decoder_stream_error_delegate_,
               OnDecoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_DECODER_STREAM_INCREMENT_OVERFLOW
-                      : QUIC_QPACK_DECODER_STREAM_ERROR,
+                  QUIC_QPACK_DECODER_STREAM_INCREMENT_OVERFLOW,
                   Eq("Insert Count Increment instruction causes overflow.")));
   encoder_.OnInsertCountIncrement(std::numeric_limits<uint64_t>::max());
 }
@@ -218,13 +209,11 @@
 TEST_F(QpackEncoderTest, InvalidHeaderAcknowledgement) {
   // Encoder receives header acknowledgement for a stream on which no header
   // block with dynamic table entries was ever sent.
-  EXPECT_CALL(decoder_stream_error_delegate_,
-              OnDecoderStreamError(
-                  GetQuicReloadableFlag(quic_granular_qpack_error_codes)
-                      ? QUIC_QPACK_DECODER_STREAM_INCORRECT_ACKNOWLEDGEMENT
-                      : QUIC_QPACK_DECODER_STREAM_ERROR,
-                  Eq("Header Acknowledgement received for stream 0 "
-                     "with no outstanding header blocks.")));
+  EXPECT_CALL(
+      decoder_stream_error_delegate_,
+      OnDecoderStreamError(QUIC_QPACK_DECODER_STREAM_INCORRECT_ACKNOWLEDGEMENT,
+                           Eq("Header Acknowledgement received for stream 0 "
+                              "with no outstanding header blocks.")));
   encoder_.OnHeaderAcknowledgement(/* stream_id = */ 0);
 }
 
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index 3d0e3f1..3a80696 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -398,7 +398,6 @@
   QUIC_QPACK_DECOMPRESSION_FAILED = 126,
 
   // Obsolete generic QPACK encoder and decoder stream error codes.
-  // (Obsoleted by gfe2_reloadable_flag_quic_granular_qpack_error_codes.)
   QUIC_QPACK_ENCODER_STREAM_ERROR = 127,
   QUIC_QPACK_DECODER_STREAM_ERROR = 128,
 
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index a79d6cc..b39cc73 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -45,7 +45,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_encrypted_goaway, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_willing_and_able_to_write2, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_goaway_with_max_stream_id, true)
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_granular_qpack_error_codes, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_parse_accept_ch_frame, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_pass_path_response_to_validator, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false)