diff --git a/quiche/http2/hpack/huffman/hpack_huffman_encoder.cc b/quiche/http2/hpack/huffman/hpack_huffman_encoder.cc
index 710ad50..df2960a 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_encoder.cc
+++ b/quiche/http2/hpack/huffman/hpack_huffman_encoder.cc
@@ -19,8 +19,8 @@
   return (bits + 7) / 8;
 }
 
-void HuffmanEncodeFast(absl::string_view input, size_t encoded_size,
-                       std::string* output) {
+void HuffmanEncode(absl::string_view input, size_t encoded_size,
+                   std::string* output) {
   const size_t original_size = output->size();
   const size_t final_size = original_size + encoded_size;
   // Reserve an extra four bytes to avoid accessing unallocated memory (even
diff --git a/quiche/http2/hpack/huffman/hpack_huffman_encoder.h b/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
index 6e49946..40daa4f 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
+++ b/quiche/http2/hpack/huffman/hpack_huffman_encoder.h
@@ -23,8 +23,8 @@
 // Encode |input| with the Huffman encoding defined RFC7541, used in HPACK and
 // QPACK.  |encoded_size| must be the value returned by HuffmanSize().
 // Appends the result to the end of |*output|.
-QUICHE_EXPORT void HuffmanEncodeFast(absl::string_view input,
-                                     size_t encoded_size, std::string* output);
+QUICHE_EXPORT void HuffmanEncode(absl::string_view input, size_t encoded_size,
+                                 std::string* output);
 
 }  // namespace http2
 
diff --git a/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc b/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc
index 83b14e2..d6774cf 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc
+++ b/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc
@@ -20,7 +20,7 @@
   EXPECT_EQ(0u, encoded_size);
 
   std::string buffer;
-  HuffmanEncodeFast(empty, encoded_size, &buffer);
+  HuffmanEncode(empty, encoded_size, &buffer);
   EXPECT_EQ("", buffer);
 }
 
@@ -46,7 +46,7 @@
     EXPECT_EQ(huffman_encoded.size(), encoded_size);
     std::string buffer;
     buffer.reserve(huffman_encoded.size());
-    HuffmanEncodeFast(plain_string, encoded_size, &buffer);
+    HuffmanEncode(plain_string, encoded_size, &buffer);
     EXPECT_EQ(buffer, huffman_encoded) << "Error encoding " << plain_string;
   }
 }
@@ -76,7 +76,7 @@
     size_t encoded_size = HuffmanSize(plain_string);
     EXPECT_EQ(huffman_encoded.size(), encoded_size);
     std::string buffer;
-    HuffmanEncodeFast(plain_string, encoded_size, &buffer);
+    HuffmanEncode(plain_string, encoded_size, &buffer);
     EXPECT_EQ(buffer, huffman_encoded) << "Error encoding " << plain_string;
   }
 }
@@ -100,7 +100,7 @@
     const std::string& plain_string = test_table[i];
     size_t encoded_size = HuffmanSize(plain_string);
     std::string huffman_encoded;
-    HuffmanEncodeFast(plain_string, encoded_size, &huffman_encoded);
+    HuffmanEncode(plain_string, encoded_size, &huffman_encoded);
     EXPECT_EQ(encoded_size, huffman_encoded.size());
   }
 }
@@ -109,13 +109,13 @@
 TEST(HuffmanEncoderTest, AppendToOutput) {
   size_t encoded_size = HuffmanSize("foo");
   std::string buffer;
-  HuffmanEncodeFast("foo", encoded_size, &buffer);
+  HuffmanEncode("foo", encoded_size, &buffer);
   std::string expected_encoding;
   ASSERT_TRUE(absl::HexStringToBytes("94e7", &expected_encoding));
   EXPECT_EQ(expected_encoding, buffer);
 
   encoded_size = HuffmanSize("bar");
-  HuffmanEncodeFast("bar", encoded_size, &buffer);
+  HuffmanEncode("bar", encoded_size, &buffer);
   ASSERT_TRUE(absl::HexStringToBytes("94e78c767f", &expected_encoding));
   EXPECT_EQ(expected_encoding, buffer);
 }
diff --git a/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc b/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
index 207f712..7596801 100644
--- a/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
+++ b/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
@@ -78,7 +78,7 @@
       absl::string_view plain, absl::string_view expected_huffman) {
     size_t encoded_size = HuffmanSize(plain);
     std::string encoded;
-    HuffmanEncodeFast(plain, encoded_size, &encoded);
+    HuffmanEncode(plain, encoded_size, &encoded);
     HTTP2_VERIFY_EQ(encoded_size, encoded.size());
     if (!expected_huffman.empty() || plain.empty()) {
       HTTP2_VERIFY_EQ(encoded, expected_huffman);
diff --git a/quiche/quic/core/qpack/qpack_instruction_encoder.cc b/quiche/quic/core/qpack/qpack_instruction_encoder.cc
index aada6ae..eeac8ce 100644
--- a/quiche/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quiche/quic/core/qpack/qpack_instruction_encoder.cc
@@ -168,7 +168,7 @@
   absl::string_view string_to_write =
       (field_->type == QpackInstructionFieldType::kName) ? name : value;
   if (use_huffman_) {
-    http2::HuffmanEncodeFast(string_to_write, string_length_, output);
+    http2::HuffmanEncode(string_to_write, string_length_, output);
   } else {
     absl::StrAppend(output, string_to_write);
   }
diff --git a/quiche/spdy/core/hpack/hpack_encoder.cc b/quiche/spdy/core/hpack/hpack_encoder.cc
index d921c2c..8d0e841 100644
--- a/quiche/spdy/core/hpack/hpack_encoder.cc
+++ b/quiche/spdy/core/hpack/hpack_encoder.cc
@@ -203,7 +203,7 @@
                     << encoded_size;
     output_stream_.AppendPrefix(kStringLiteralHuffmanEncoded);
     output_stream_.AppendUint32(encoded_size);
-    http2::HuffmanEncodeFast(str, encoded_size, output_stream_.MutableString());
+    http2::HuffmanEncode(str, encoded_size, output_stream_.MutableString());
   } else {
     QUICHE_DVLOG(2) << "Emitted literal string of length " << str.size();
     output_stream_.AppendPrefix(kStringLiteralIdentityEncoded);
diff --git a/quiche/spdy/core/hpack/hpack_encoder_test.cc b/quiche/spdy/core/hpack/hpack_encoder_test.cc
index 1d23317..2d09358 100644
--- a/quiche/spdy/core/hpack/hpack_encoder_test.cc
+++ b/quiche/spdy/core/hpack/hpack_encoder_test.cc
@@ -209,7 +209,7 @@
     if (encoded_size < str.size()) {
       expected_.AppendPrefix(kStringLiteralHuffmanEncoded);
       expected_.AppendUint32(encoded_size);
-      http2::HuffmanEncodeFast(str, encoded_size, stream->MutableString());
+      http2::HuffmanEncode(str, encoded_size, stream->MutableString());
     } else {
       expected_.AppendPrefix(kStringLiteralIdentityEncoded);
       expected_.AppendUint32(str.size());