Index: net/http2/hpack/decoder/hpack_block_collector.cc |
diff --git a/net/http2/hpack/decoder/hpack_block_collector.cc b/net/http2/hpack/decoder/hpack_block_collector.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..94f58ee408a383183bb5475fbbb95209fdbd1ddb |
--- /dev/null |
+++ b/net/http2/hpack/decoder/hpack_block_collector.cc |
@@ -0,0 +1,154 @@ |
+// 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/http2/hpack/decoder/hpack_block_collector.h" |
+ |
+#include <algorithm> |
+#include <memory> |
+ |
+#include "base/logging.h" |
+#include "net/http2/tools/failure.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+using ::testing::AssertionResult; |
+using ::testing::AssertionSuccess; |
+using std::string; |
+ |
+using base::StringPiece; |
+ |
+namespace net { |
+namespace test { |
+ |
+HpackBlockCollector::HpackBlockCollector() {} |
+HpackBlockCollector::HpackBlockCollector(const HpackBlockCollector& other) |
+ : pending_entry_(other.pending_entry_), entries_(other.entries_) {} |
+HpackBlockCollector::~HpackBlockCollector() {} |
+ |
+void HpackBlockCollector::OnIndexedHeader(size_t index) { |
+ pending_entry_.OnIndexedHeader(index); |
+ PushPendingEntry(); |
+} |
+void HpackBlockCollector::OnDynamicTableSizeUpdate(size_t size) { |
+ pending_entry_.OnDynamicTableSizeUpdate(size); |
+ PushPendingEntry(); |
+} |
+void HpackBlockCollector::OnStartLiteralHeader(HpackEntryType header_type, |
+ size_t maybe_name_index) { |
+ pending_entry_.OnStartLiteralHeader(header_type, maybe_name_index); |
+} |
+void HpackBlockCollector::OnNameStart(bool huffman_encoded, size_t len) { |
+ pending_entry_.OnNameStart(huffman_encoded, len); |
+} |
+void HpackBlockCollector::OnNameData(const char* data, size_t len) { |
+ pending_entry_.OnNameData(data, len); |
+} |
+void HpackBlockCollector::OnNameEnd() { |
+ pending_entry_.OnNameEnd(); |
+} |
+void HpackBlockCollector::OnValueStart(bool huffman_encoded, size_t len) { |
+ pending_entry_.OnValueStart(huffman_encoded, len); |
+} |
+void HpackBlockCollector::OnValueData(const char* data, size_t len) { |
+ pending_entry_.OnValueData(data, len); |
+} |
+void HpackBlockCollector::OnValueEnd() { |
+ pending_entry_.OnValueEnd(); |
+ PushPendingEntry(); |
+} |
+ |
+void HpackBlockCollector::PushPendingEntry() { |
+ EXPECT_TRUE(pending_entry_.IsComplete()); |
+ DVLOG(2) << "PushPendingEntry: " << pending_entry_; |
+ entries_.push_back(pending_entry_); |
+ EXPECT_TRUE(entries_.back().IsComplete()); |
+ pending_entry_.Clear(); |
+} |
+void HpackBlockCollector::Clear() { |
+ pending_entry_.Clear(); |
+ entries_.clear(); |
+} |
+ |
+void HpackBlockCollector::ExpectIndexedHeader(size_t index) { |
+ entries_.push_back( |
+ HpackEntryCollector(HpackEntryType::kIndexedHeader, index)); |
+} |
+void HpackBlockCollector::ExpectDynamicTableSizeUpdate(size_t size) { |
+ entries_.push_back( |
+ HpackEntryCollector(HpackEntryType::kDynamicTableSizeUpdate, size)); |
+} |
+void HpackBlockCollector::ExpectNameIndexAndLiteralValue(HpackEntryType type, |
+ size_t index, |
+ bool value_huffman, |
+ const string& value) { |
+ entries_.push_back(HpackEntryCollector(type, index, value_huffman, value)); |
+} |
+void HpackBlockCollector::ExpectLiteralNameAndValue(HpackEntryType type, |
+ bool name_huffman, |
+ const string& name, |
+ bool value_huffman, |
+ const string& value) { |
+ entries_.push_back( |
+ HpackEntryCollector(type, name_huffman, name, value_huffman, value)); |
+} |
+ |
+void HpackBlockCollector::ShuffleEntries(RandomBase* rng) { |
+ std::random_shuffle(entries_.begin(), entries_.end()); |
+} |
+ |
+void HpackBlockCollector::AppendToHpackBlockBuilder( |
+ HpackBlockBuilder* hbb) const { |
+ CHECK(IsNotPending()); |
+ for (const auto& entry : entries_) { |
+ entry.AppendToHpackBlockBuilder(hbb); |
+ } |
+} |
+ |
+AssertionResult HpackBlockCollector::ValidateSoleIndexedHeader( |
+ size_t ndx) const { |
+ VERIFY_TRUE(pending_entry_.IsClear()); |
+ VERIFY_EQ(1u, entries_.size()); |
+ VERIFY_TRUE(entries_.front().ValidateIndexedHeader(ndx)); |
+ return AssertionSuccess(); |
+} |
+AssertionResult HpackBlockCollector::ValidateSoleLiteralValueHeader( |
+ HpackEntryType expected_type, |
+ size_t expected_index, |
+ bool expected_value_huffman, |
+ StringPiece expected_value) const { |
+ VERIFY_TRUE(pending_entry_.IsClear()); |
+ VERIFY_EQ(1u, entries_.size()); |
+ VERIFY_TRUE(entries_.front().ValidateLiteralValueHeader( |
+ expected_type, expected_index, expected_value_huffman, expected_value)); |
+ return AssertionSuccess(); |
+} |
+AssertionResult HpackBlockCollector::ValidateSoleLiteralNameValueHeader( |
+ HpackEntryType expected_type, |
+ bool expected_name_huffman, |
+ StringPiece expected_name, |
+ bool expected_value_huffman, |
+ StringPiece expected_value) const { |
+ VERIFY_TRUE(pending_entry_.IsClear()); |
+ VERIFY_EQ(1u, entries_.size()); |
+ VERIFY_TRUE(entries_.front().ValidateLiteralNameValueHeader( |
+ expected_type, expected_name_huffman, expected_name, |
+ expected_value_huffman, expected_value)); |
+ return AssertionSuccess(); |
+} |
+AssertionResult HpackBlockCollector::ValidateSoleDynamicTableSizeUpdate( |
+ size_t size) const { |
+ VERIFY_TRUE(pending_entry_.IsClear()); |
+ VERIFY_EQ(1u, entries_.size()); |
+ VERIFY_TRUE(entries_.front().ValidateDynamicTableSizeUpdate(size)); |
+ return AssertionSuccess(); |
+} |
+ |
+AssertionResult HpackBlockCollector::VerifyEq( |
+ const HpackBlockCollector& that) const { |
+ VERIFY_EQ(pending_entry_, that.pending_entry_); |
+ VERIFY_EQ(entries_, that.entries_); |
+ return AssertionSuccess(); |
+} |
+ |
+} // namespace test |
+} // namespace net |