SPDY & HPACK: Land recent internal changes (through 65328503)

net/spdy/hpack_decoder_test.cc

 // Copyright 2014 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/spdy/hpack_decoder.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "net/spdy/hpack_encoder.h"
 #include "net/spdy/hpack_input_stream.h"
 #include "net/spdy/hpack_output_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace test {
 
 using base::StringPiece;
 using std::string;
 
-class HpackEncodingContextPeer {
- public:
-  explicit HpackEncodingContextPeer(const HpackEncodingContext& context)
-      : context_(context) {}
-  const HpackHeaderTable& header_table() {
-    return context_.header_table_;
-  }
-
- private:
-  const HpackEncodingContext& context_;
-};
-
 class HpackDecoderPeer {
  public:
   explicit HpackDecoderPeer(HpackDecoder* decoder)
       : decoder_(decoder) {}
 
   void HandleHeaderRepresentation(StringPiece name, StringPiece value) {
     decoder_->HandleHeaderRepresentation(name, value);
   }
   bool DecodeNextName(HpackInputStream* in, StringPiece* out) {
     return decoder_->DecodeNextName(in, out);
   }
-  HpackEncodingContextPeer context_peer() {
-    return HpackEncodingContextPeer(decoder_->context_);
+  const HpackHeaderTable& header_table() {
+    return decoder_->header_table_;
   }
   void set_cookie_name(string name) {
     decoder_->cookie_name_ = name;
   }
   string cookie_name() {
     return decoder_->cookie_name_;
   }
   void set_cookie_value(string value) {
     decoder_->cookie_value_ = value;
   }
@@ skipping 20 matching lines @@
 
 using testing::ElementsAre;
 using testing::Pair;
 
 const size_t kLiteralBound = 1024;
 
 class HpackDecoderTest : public ::testing::Test {
  protected:
   HpackDecoderTest()
       : decoder_(ObtainHpackHuffmanTable()),
-        decoder_peer_(&decoder_),
-        context_peer_(decoder_peer_.context_peer()) {}
+        decoder_peer_(&decoder_) {}
 
   bool DecodeHeaderBlock(StringPiece str) {
     return decoder_.HandleControlFrameHeadersData(0, str.data(), str.size()) &&
         decoder_.HandleControlFrameHeadersComplete(0);
   }
   const std::map<string, string>& decoded_block() const {
     // TODO(jgraettinger): HpackDecoderTest should implement
     // SpdyHeadersHandlerInterface, and collect headers for examination.
     return decoder_peer_.decoded_block();
   }
   // TODO(jgraettinger): Eliminate uses of this in tests below. Prefer
   // DecodeHeaderBlock().
   const std::map<string, string>& DecodeUniqueHeaderSet(StringPiece str) {
     EXPECT_TRUE(DecodeHeaderBlock(str));
     return decoded_block();
   }
 
   HpackDecoder decoder_;
   test::HpackDecoderPeer decoder_peer_;
-  test::HpackEncodingContextPeer context_peer_;
 };
 
 TEST_F(HpackDecoderTest, HandleControlFrameHeadersData) {
   // Strings under threshold are concatenated in the buffer.
   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData(
       0, "small string one", 16));
   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData(
       0, "small string two", 16));
   // A string which would push the buffer over the threshold is refused.
   EXPECT_FALSE(decoder_.HandleControlFrameHeadersData(
@@ skipping 127 matching lines @@
 }
 
 // Test a too-large indexed header.
 TEST_F(HpackDecoderTest, InvalidIndexedHeader) {
   // High-bit set, and a prefix of one more than the number of static entries.
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\xbd", 1)));
 }
 
 TEST_F(HpackDecoderTest, ContextUpdateMaximumSize) {
   EXPECT_EQ(kDefaultHeaderTableSizeSetting,
-            context_peer_.header_table().max_size());
+            decoder_peer_.header_table().max_size());
   {
     // Maximum-size update with size 126. Succeeds.
     EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x80\x7e", 2)));
-    EXPECT_EQ(126u, context_peer_.header_table().max_size());
+    EXPECT_EQ(126u, decoder_peer_.header_table().max_size());
   }
   string input;
   {
     // Maximum-size update with kDefaultHeaderTableSizeSetting. Succeeds.
-    HpackOutputStream output_stream(kuint32max);
+    HpackOutputStream output_stream;
     output_stream.AppendBits(0x80, 8);  // Context update.
     output_stream.AppendBits(0x00, 1);  // Size update.
-    output_stream.AppendUint32ForTest(kDefaultHeaderTableSizeSetting);
+    output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
 
     output_stream.TakeString(&input);
     EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
-              context_peer_.header_table().max_size());
+              decoder_peer_.header_table().max_size());
   }
   {
     // Maximum-size update with kDefaultHeaderTableSizeSetting + 1. Fails.
-    HpackOutputStream output_stream(kuint32max);
+    HpackOutputStream output_stream;
     output_stream.AppendBits(0x80, 8);  // Context update.
     output_stream.AppendBits(0x00, 1);  // Size update.
-    output_stream.AppendUint32ForTest(kDefaultHeaderTableSizeSetting + 1);
+    output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
 
     output_stream.TakeString(&input);
     EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
-              context_peer_.header_table().max_size());
+              decoder_peer_.header_table().max_size());
   }
 }
 
 TEST_F(HpackDecoderTest, ContextUpdateClearReferenceSet) {
   // Toggle on a couple of headers.
   std::map<string, string> header_set1 =
       DecodeUniqueHeaderSet("\x82\x86");
   std::map<string, string> expected_header_set1;
   expected_header_set1[":method"] = "GET";
   expected_header_set1[":path"] = "/index.html";
@@ skipping 49 matching lines @@
 
   // Incremental indexing.
 
   // One more than the number of static table entries.
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x3d", 1)));
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x00", 1)));
 }
 
 // Round-tripping the header set from E.2.1 should work.
 TEST_F(HpackDecoderTest, BasicE21) {
-  HpackEncoder encoder;
+  HpackEncoder encoder(ObtainHpackHuffmanTable());
 
   std::map<string, string> expected_header_set;
   expected_header_set[":method"] = "GET";
   expected_header_set[":scheme"] = "http";
   expected_header_set[":path"] = "/";
   expected_header_set[":authority"] = "www.example.com";
 
   string encoded_header_set;
   EXPECT_TRUE(encoder.EncodeHeaderSet(
       expected_header_set, &encoded_header_set));
@@ skipping 243 matching lines @@
       Pair("content-encoding", "gzip"),
       Pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
       Pair("location", "https://www.example.com"),
       Pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
            " max-age=3600; version=1")));
 }
 
 }  // namespace
 
 }  // namespace net