diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index f1a21ea..a455238 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -37,7 +37,9 @@
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/packet_dropping_test_writer.h"
 #include "net/third_party/quiche/src/quic/test_tools/packet_reordering_writer.h"
+#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_test_utils.h"
+#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_header_table_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_client_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
@@ -2410,6 +2412,23 @@
   SetPacketLossPercentage(30);
   client_writer_->set_fake_blocked_socket_percentage(10);
 
+  // Wait for SETTINGS frame from server that sets QPACK dynamic table capacity
+  // to make sure request headers will be compressed using the dynamic table.
+  if (version_.UsesHttp3()) {
+    while (true) {
+      // Waits for up to 50 ms.
+      client_->client()->WaitForEvents();
+      if (!GetClientSession() || !GetClientSession()->qpack_encoder()) {
+        continue;
+      }
+      QpackHeaderTable* header_table =
+          QpackEncoderPeer::header_table(GetClientSession()->qpack_encoder());
+      if (QpackHeaderTablePeer::dynamic_table_capacity(header_table) > 0) {
+        break;
+      }
+    }
+  }
+
   // Create a POST request and send the headers only.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
@@ -2419,54 +2438,33 @@
 
   client_->SendMessage(headers, "", /*fin=*/false);
 
-  // Bounds on the size of headers on the request stream. These are both zero
-  // if headers are sent on the header stream. The connection might send the
-  // /foo request before or after receiving the peer's SETTINGS, which
-  // would impact whether QPACK uses the dynamic table or not, so we have two
-  // potential expected values.
-  size_t header_size_low = 0;
-  size_t header_size_high = 0;
+  // Size of headers on the request stream. This is zero if headers are sent on
+  // the header stream.
+  size_t header_size = 0;
   if (version_.UsesHttp3()) {
     // Determine size of headers after QPACK compression in both scenarios.
     NoopDecoderStreamErrorDelegate decoder_stream_error_delegate;
     NoopQpackStreamSenderDelegate encoder_stream_sender_delegate;
-    QpackEncoder qpack_encoder_low(&decoder_stream_error_delegate);
-    qpack_encoder_low.set_qpack_stream_sender_delegate(
+    QpackEncoder qpack_encoder(&decoder_stream_error_delegate);
+    qpack_encoder.set_qpack_stream_sender_delegate(
         &encoder_stream_sender_delegate);
 
-    qpack_encoder_low.SetMaximumDynamicTableCapacity(
+    qpack_encoder.SetMaximumDynamicTableCapacity(
         kDefaultQpackMaxDynamicTableCapacity);
-    qpack_encoder_low.SetDynamicTableCapacity(
-        kDefaultQpackMaxDynamicTableCapacity);
-    qpack_encoder_low.SetMaximumBlockedStreams(kDefaultMaximumBlockedStreams);
+    qpack_encoder.SetDynamicTableCapacity(kDefaultQpackMaxDynamicTableCapacity);
+    qpack_encoder.SetMaximumBlockedStreams(kDefaultMaximumBlockedStreams);
 
-    std::string encoded_headers_low = qpack_encoder_low.EncodeHeaderList(
+    std::string encoded_headers = qpack_encoder.EncodeHeaderList(
         /* stream_id = */ 0, headers, nullptr);
-    header_size_low = encoded_headers_low.size();
-
-    QpackEncoder qpack_encoder_high(&decoder_stream_error_delegate);
-    qpack_encoder_high.set_qpack_stream_sender_delegate(
-        &encoder_stream_sender_delegate);
-
-    qpack_encoder_high.SetMaximumDynamicTableCapacity(0);
-    qpack_encoder_high.SetDynamicTableCapacity(0);
-    qpack_encoder_high.SetMaximumBlockedStreams(0);
-
-    std::string encoded_headers_high = qpack_encoder_high.EncodeHeaderList(
-        /* stream_id = */ 0, headers, nullptr);
-    header_size_high = encoded_headers_high.size();
+    header_size = encoded_headers.size();
   }
-  ASSERT_LE(header_size_low, header_size_high);
 
   // Test the AckNotifier's ability to track multiple packets by making the
   // request body exceed the size of a single packet.
   std::string request_string = "a request body bigger than one packet" +
                                std::string(kMaxOutgoingPacketSize, '.');
 
-  const int expected_bytes_acked_low =
-      header_size_low + request_string.length();
-  const int expected_bytes_acked_high =
-      header_size_high + request_string.length();
+  const int expected_bytes_acked = header_size + request_string.length();
 
   // The TestAckListener will cause a failure if not notified.
   QuicReferenceCountedPointer<TestAckListener> ack_listener(
@@ -2482,20 +2480,13 @@
   client_->SendSynchronousRequest("/bar");
 
   // Make sure the delegate does get the notification it expects.
-  while (ack_listener->total_bytes_acked() < expected_bytes_acked_low) {
+  while (ack_listener->total_bytes_acked() < expected_bytes_acked) {
     // Waits for up to 50 ms.
     client_->client()->WaitForEvents();
   }
-  if (expected_bytes_acked_low != expected_bytes_acked_high) {
-    EXPECT_TRUE(ack_listener->total_bytes_acked() == expected_bytes_acked_low ||
-                ack_listener->total_bytes_acked() == expected_bytes_acked_high)
-        << " header_size_low " << header_size_low << " header_size_high "
-        << header_size_low << " request length " << request_string.length();
-  } else {
-    EXPECT_EQ(ack_listener->total_bytes_acked(), expected_bytes_acked_low)
-        << " header_size " << header_size_low << " request length "
-        << request_string.length();
-  }
+  EXPECT_EQ(ack_listener->total_bytes_acked(), expected_bytes_acked)
+      << " header_size " << header_size << " request length "
+      << request_string.length();
 }
 
 // Send a public reset from the server.