Plumbs new SpdyFramerVisitorInterface method handling through QUIC test utilities, including the te…

net/quic/spdy_utils.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/spdy_utils.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "url/gurl.h"
 
+using base::StringPiece;
 using std::string;
 using std::vector;
 
 namespace net {
 
 // static
 string SpdyUtils::SerializeUncompressedHeaders(const SpdyHeaderBlock& headers) {
   SpdyMajorVersion spdy_version = HTTP2;
 
   size_t length = SpdyFramer::GetSerializedLength(spdy_version, &headers);
@@ skipping 72 matching lines @@
       return false;
     }
 
     // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
   }
 
   DVLOG(1) << "Successfully parsed Trailers.";
   return true;
 }
 
+bool SpdyUtils::CopyAndValidateHeaders(const QuicHeaderList& header_list,
+                                       int64_t* content_length,
+                                       SpdyHeaderBlock* headers) {
+  for (const auto& p : header_list) {
+    const string& name = p.first;
+    if (name.empty()) {
+      DVLOG(1) << "Header name must not be empty.";
+      return false;
+    }
+
+    if (std::any_of(name.begin(), name.end(), base::IsAsciiUpper<char>)) {
+      DLOG(ERROR) << "Malformed header: Header name " << name
+                  << " contains upper-case characters.";
+      return false;
+    }
+
+    if (headers->find(name) != headers->end()) {
+      DLOG(ERROR) << "Duplicate header '" << name << "' found.";
+      return false;
+    }
+
+    (*headers)[name] = p.second;
+  }
+
+  if (ContainsKey(*headers, "content-length")) {
+    // Check whether multiple values are consistent.
+    StringPiece content_length_header = (*headers)["content-length"];
+    vector<string> values =
+        base::SplitString(content_length_header, base::StringPiece("\0", 1),
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    for (const string& value : values) {
+      int new_value;
+      if (!base::StringToInt(value, &new_value) || new_value < 0) {
+        DLOG(ERROR) << "Content length was either unparseable or negative.";
+        return false;
+      }
+      if (*content_length < 0) {
+        *content_length = new_value;
+        continue;
+      }
+      if (new_value != *content_length) {
+        DLOG(ERROR) << "Parsed content length " << new_value << " is "
+                    << "inconsistent with previously detected content length "
+                    << *content_length;
+        return false;
+      }
+    }
+  }
+
+  DVLOG(1) << "Successfully parsed headers: " << headers->DebugString();
+  return true;
+}
+
 bool SpdyUtils::CopyAndValidateTrailers(const QuicHeaderList& header_list,
                                         size_t* final_byte_offset,
                                         SpdyHeaderBlock* trailers) {
+  bool found_final_byte_offset = false;
   for (const auto& p : header_list) {
     const string& name = p.first;
+
+    int new_value;
+    // Pull out the final offset pseudo header which indicates the number of
+    // response body bytes expected.
+    if (!found_final_byte_offset && name == kFinalOffsetHeaderKey &&
+        base::StringToInt(p.second, &new_value)) {
+      *final_byte_offset = new_value;
+      found_final_byte_offset = true;
+      continue;
+    }
+
     if (name.empty() || name[0] == ':') {
       DVLOG(1) << "Trailers must not be empty, and must not contain pseudo-"
                << "headers. Found: '" << name << "'";
       return false;
     }
 
     if (std::any_of(name.begin(), name.end(), base::IsAsciiUpper<char>)) {
       DVLOG(1) << "Malformed header: Header name " << name
                << " contains upper-case characters.";
       return false;
     }
 
     if (trailers->find(name) != trailers->end()) {
       DVLOG(1) << "Duplicate header '" << name << "' found in trailers.";
       return false;
     }
 
     (*trailers)[name] = p.second;
   }
 
-  if (trailers->empty()) {
-    DVLOG(1) << "Request Trailers are invalid.";
-    return false;  // Trailers were invalid.
-  }
-
-  // Pull out the final offset pseudo header which indicates the number of
-  // response body bytes expected.
-  auto it = trailers->find(kFinalOffsetHeaderKey);
-  if (it == trailers->end() || !StringToSizeT(it->second, final_byte_offset)) {
+  if (!found_final_byte_offset) {
     DVLOG(1) << "Required key '" << kFinalOffsetHeaderKey << "' not present";
     return false;
   }
-  // The final offset header is no longer needed.
-  trailers->erase(it->first);
 
   // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
 
   DVLOG(1) << "Successfully parsed Trailers: " << trailers->DebugString();
   return true;
 }
 
 // static
 string SpdyUtils::GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers) {
   SpdyHeaderBlock::const_iterator it = headers.find(":scheme");
@@ skipping 23 matching lines @@
   return GURL(GetUrlFromHeaderBlock(headers)).host();
 }
 
 // static
 bool SpdyUtils::UrlIsValid(const SpdyHeaderBlock& headers) {
   string url(GetUrlFromHeaderBlock(headers));
   return url != "" && GURL(url).is_valid();
 }
 
 }  // namespace net