relnote: add new unused functions for client side of QUIC server push.

net/quic/spdy_utils_test.cc

Index: net/quic/spdy_utils_test.cc
diff --git a/net/quic/spdy_utils_test.cc b/net/quic/spdy_utils_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b727638caa2a6d1eebb47e23b6c666eb9f656425
--- /dev/null
+++ b/net/quic/spdy_utils_test.cc
@@ -0,0 +1,140 @@
+// Copyright 2016 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 "base/macros.h"
+#include "base/strings/string_number_conversions.h"
+#include "net/test/gtest_util.h"
+
+using std::string;
+
+namespace net {
+namespace test {
+
+TEST(SpdyUtilsTest, SerializeAndParseHeaders) {
+  // Creates a SpdyHeaderBlock with some key->value pairs, serializes it, then
+  // parses the serialized output and verifies that the end result is the same
+  // as the headers that the test started with.
+
+  SpdyHeaderBlock input_headers;
+  input_headers[":pseudo1"] = "pseudo value1";
+  input_headers[":pseudo2"] = "pseudo value2";
+  input_headers["key1"] = "value1";
+  const int kContentLength = 1234;
+  input_headers["content-length"] = base::IntToString(kContentLength);
+  input_headers["key2"] = "value2";
+
+  // Serialize the header block.
+  string serialized_headers =
+      SpdyUtils::SerializeUncompressedHeaders(input_headers);
+
+  // Take the serialized header block, and parse back into SpdyHeaderBlock.
+  SpdyHeaderBlock output_headers;
+  int content_length = -1;
+  ASSERT_TRUE(SpdyUtils::ParseHeaders(serialized_headers.data(),
+                                      serialized_headers.size(),
+                                      &content_length, &output_headers));
+
+  // Should be back to the original headers.
+  EXPECT_EQ(content_length, kContentLength);
+  EXPECT_EQ(output_headers, input_headers);
+}
+
+TEST(SpdyUtilsTest, SerializeAndParseValidTrailers) {
+  // Creates a SpdyHeaderBlock with some valid Trailers key->value pairs,
+  // serializes it, then parses the serialized output and verifies that the end
+  // result is the same as the trailers that the test started with.
+  SpdyHeaderBlock input_trailers;
+  const size_t kFinalOffset = 5678;
+  input_trailers[kFinalOffsetHeaderKey] = base::IntToString(kFinalOffset);
+  input_trailers["key1"] = "value1";
+  input_trailers["key2"] = "value2";
+
+  // Serialize the trailers.
+  string serialized_trailers =
+      SpdyUtils::SerializeUncompressedHeaders(input_trailers);
+
+  // Take the serialized trailers, and parse back into a SpdyHeaderBlock.
+  SpdyHeaderBlock output_trailers;
+  size_t final_byte_offset = 0;
+  EXPECT_TRUE(SpdyUtils::ParseTrailers(serialized_trailers.data(),
+                                       serialized_trailers.size(),
+                                       &final_byte_offset, &output_trailers));
+
+  // Should be back to the original trailers, without the final offset header.
+  EXPECT_EQ(final_byte_offset, kFinalOffset);
+  input_trailers.erase(kFinalOffsetHeaderKey);
+  EXPECT_EQ(output_trailers, input_trailers);
+}
+
+TEST(SpdyUtilsTest, SerializeAndParseTrailersWithoutFinalOffset) {
+  // Verifies that parsing fails if Trailers are missing a final offset header.
+
+  SpdyHeaderBlock input_trailers;
+  input_trailers["key1"] = "value1";
+  input_trailers["key2"] = "value2";
+
+  // Serialize the trailers.
+  string serialized_trailers =
+      SpdyUtils::SerializeUncompressedHeaders(input_trailers);
+
+  // Parsing the serialized trailers fails because of the missing final offset.
+  SpdyHeaderBlock output_trailers;
+  size_t final_byte_offset = 0;
+  EXPECT_FALSE(SpdyUtils::ParseTrailers(serialized_trailers.data(),
+                                        serialized_trailers.size(),
+                                        &final_byte_offset, &output_trailers));
+  EXPECT_EQ(final_byte_offset, 0u);
+}
+
+TEST(SpdyUtilsTest, SerializeAndParseTrailersWithPseudoHeaders) {
+  // Verifies that parsing fails if Trailers include pseudo-headers.
+
+  SpdyHeaderBlock input_trailers;
+  input_trailers[kFinalOffsetHeaderKey] = "12345";
+  input_trailers[":disallowed-pseudo-header"] = "pseudo value";
+  input_trailers["key1"] = "value1";
+  input_trailers["key2"] = "value2";
+
+  // Serialize the trailers.
+  string serialized_trailers =
+      SpdyUtils::SerializeUncompressedHeaders(input_trailers);
+
+  // Parsing the serialized trailers fails because of the extra pseudo header.
+  SpdyHeaderBlock output_trailers;
+  size_t final_byte_offset = 0;
+  EXPECT_FALSE(SpdyUtils::ParseTrailers(serialized_trailers.data(),
+                                        serialized_trailers.size(),
+                                        &final_byte_offset, &output_trailers));
+}
+
+TEST(SpdyUtilsTest, GetUrlFromHeaderBlock) {
+  SpdyHeaderBlock headers;
+  EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
+  headers[":scheme"] = "https";
+  EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
+  headers[":authority"] = "www.google.com";
+  EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
+  headers[":path"] = "/index.html";
+  EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers),
+            "https://www.google.com/index.html");
+  headers["key1"] = "value1";
+  headers["key2"] = "value2";
+  EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers),
+            "https://www.google.com/index.html");
+}
+
+TEST(SpdyUtilsTest, UrlIsValid) {
+  SpdyHeaderBlock headers;
+  EXPECT_FALSE(SpdyUtils::UrlIsValid(headers));
+  headers[":scheme"] = "https";
+  EXPECT_FALSE(SpdyUtils::UrlIsValid(headers));
+  headers[":authority"] = "www.google.com";
+  EXPECT_FALSE(SpdyUtils::UrlIsValid(headers));
+  headers[":path"] = "/index.html";
+  EXPECT_TRUE(SpdyUtils::UrlIsValid(headers));
+}
+
+}  // namespace test
+}  // namespace net_quic