diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index fd77668..674b076 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -449,7 +449,9 @@
   }
 
   size_t final_byte_offset = 0;
-  if (!SpdyUtils::CopyAndValidateTrailers(header_list, &final_byte_offset,
+  if (!SpdyUtils::CopyAndValidateTrailers(header_list,
+                                          /* expect_final_byte_offset = */ true,
+                                          &final_byte_offset,
                                           &received_trailers_)) {
     QUIC_DLOG(ERROR) << "Trailers for stream " << id() << " are malformed.";
     session()->connection()->CloseConnection(
diff --git a/quic/core/http/spdy_utils.cc b/quic/core/http/spdy_utils.cc
index 2d94fd4..721ae33 100644
--- a/quic/core/http/spdy_utils.cc
+++ b/quic/core/http/spdy_utils.cc
@@ -86,6 +86,7 @@
 }
 
 bool SpdyUtils::CopyAndValidateTrailers(const QuicHeaderList& header_list,
+                                        bool expect_final_byte_offset,
                                         size_t* final_byte_offset,
                                         SpdyHeaderBlock* trailers) {
   bool found_final_byte_offset = false;
@@ -94,7 +95,8 @@
 
     // Pull out the final offset pseudo header which indicates the number of
     // response body bytes expected.
-    if (!found_final_byte_offset && name == kFinalOffsetHeaderKey &&
+    if (expect_final_byte_offset && !found_final_byte_offset &&
+        name == kFinalOffsetHeaderKey &&
         QuicTextUtils::StringToSizeT(p.second, final_byte_offset)) {
       found_final_byte_offset = true;
       continue;
@@ -116,7 +118,7 @@
     trailers->AppendValueOrAddHeader(name, p.second);
   }
 
-  if (!found_final_byte_offset) {
+  if (expect_final_byte_offset && !found_final_byte_offset) {
     QUIC_DLOG(ERROR) << "Required key '" << kFinalOffsetHeaderKey
                      << "' not present";
     return false;
diff --git a/quic/core/http/spdy_utils.h b/quic/core/http/spdy_utils.h
index 444dd7f..dc3fabc 100644
--- a/quic/core/http/spdy_utils.h
+++ b/quic/core/http/spdy_utils.h
@@ -32,7 +32,17 @@
                                      spdy::SpdyHeaderBlock* headers);
 
   // Copies a list of headers to a SpdyHeaderBlock.
+  // If |expect_final_byte_offset| is true, requires exactly one header field
+  // with key kFinalOffsetHeaderKey and an integer value.
+  // If |expect_final_byte_offset| is false, no kFinalOffsetHeaderKey may be
+  // present.
+  // Returns true if parsing is successful.  Returns false if the presence of
+  // kFinalOffsetHeaderKey does not match the value of
+  // |expect_final_byte_offset|, the kFinalOffsetHeaderKey value cannot be
+  // parsed, any other pseudo-header is present, an empty header key is present,
+  // or a header key contains an uppercase character.
   static bool CopyAndValidateTrailers(const QuicHeaderList& header_list,
+                                      bool expect_final_byte_offset,
                                       size_t* final_byte_offset,
                                       spdy::SpdyHeaderBlock* trailers);
 
diff --git a/quic/core/http/spdy_utils_test.cc b/quic/core/http/spdy_utils_test.cc
index b7da0fd..d5c96fb 100644
--- a/quic/core/http/spdy_utils_test.cc
+++ b/quic/core/http/spdy_utils_test.cc
@@ -17,6 +17,10 @@
 
 namespace quic {
 namespace test {
+namespace {
+
+const bool kExpectFinalByteOffset = true;
+const bool kDoNotExpectFinalByteOffset = false;
 
 static std::unique_ptr<QuicHeaderList> FromList(
     const QuicHeaderList::ListType& src) {
@@ -29,6 +33,8 @@
   return headers;
 }
 
+}  // anonymous namespace
+
 using CopyAndValidateHeaders = QuicTest;
 
 TEST_F(CopyAndValidateHeaders, NormalUsage) {
@@ -202,29 +208,62 @@
   auto trailers = FromList({{kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                 &block));
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_EQ(1234u, final_byte_offset);
 }
 
-TEST_F(CopyAndValidateTrailers, EmptyTrailerList) {
-  // An empty trailer list will fail as required key kFinalOffsetHeaderKey is
+TEST_F(CopyAndValidateTrailers, EmptyTrailerListWithFinalByteOffsetExpected) {
+  // An empty trailer list will fail as expected key kFinalOffsetHeaderKey is
   // not present.
   QuicHeaderList trailers;
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_FALSE(
-      SpdyUtils::CopyAndValidateTrailers(trailers, &final_byte_offset, &block));
+  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
+      trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
 
-TEST_F(CopyAndValidateTrailers, FinalByteOffsetNotPresent) {
-  // Validation fails if required kFinalOffsetHeaderKey is not present, even if
+TEST_F(CopyAndValidateTrailers,
+       EmptyTrailerListWithFinalByteOffsetNotExpected) {
+  // An empty trailer list will pass successfully if kFinalOffsetHeaderKey is
+  // not expected.
+  QuicHeaderList trailers;
+  size_t final_byte_offset = 0;
+  SpdyHeaderBlock block;
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
+      trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
+  EXPECT_TRUE(block.empty());
+}
+
+TEST_F(CopyAndValidateTrailers, FinalByteOffsetExpectedButNotPresent) {
+  // Validation fails if expected kFinalOffsetHeaderKey is not present, even if
   // the rest of the header block is valid.
   auto trailers = FromList({{"key", "value"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                  &block));
+  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
+}
+
+TEST_F(CopyAndValidateTrailers, FinalByteOffsetNotExpectedButPresent) {
+  // Validation fails if kFinalOffsetHeaderKey is present but should not be,
+  // even if the rest of the header block is valid.
+  auto trailers = FromList({{"key", "value"}, {kFinalOffsetHeaderKey, "1234"}});
+  size_t final_byte_offset = 0;
+  SpdyHeaderBlock block;
+  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
+}
+
+TEST_F(CopyAndValidateTrailers, FinalByteOffsetNotExpectedAndNotPresent) {
+  // Validation succeeds if kFinalOffsetHeaderKey is not expected and not
+  // present.
+  auto trailers = FromList({{"key", "value"}});
+  size_t final_byte_offset = 0;
+  SpdyHeaderBlock block;
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kDoNotExpectFinalByteOffset, &final_byte_offset, &block));
+  EXPECT_THAT(block, UnorderedElementsAre(Pair("key", "value")));
 }
 
 TEST_F(CopyAndValidateTrailers, EmptyName) {
@@ -233,8 +272,8 @@
   auto trailers = FromList({{"", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                  &block));
+  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
 
 TEST_F(CopyAndValidateTrailers, PseudoHeaderInTrailers) {
@@ -243,8 +282,8 @@
       FromList({{":pseudo_key", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                  &block));
+  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
 }
 
 TEST_F(CopyAndValidateTrailers, DuplicateTrailers) {
@@ -262,8 +301,8 @@
                             {"key", "non_contiguous_duplicate"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                 &block));
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
+      *trailers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_THAT(
       block,
       UnorderedElementsAre(
@@ -286,8 +325,8 @@
 
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_TRUE(
-      SpdyUtils::CopyAndValidateTrailers(*headers, &final_byte_offset, &block));
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(
+      *headers, kExpectFinalByteOffset, &final_byte_offset, &block));
   EXPECT_THAT(
       block,
       UnorderedElementsAre(