Revert of Add new HTTP/2 and HPACK decoder in net/http2/.

net/http2/hpack/decoder/hpack_entry_collector.cc

Index: net/http2/hpack/decoder/hpack_entry_collector.cc
diff --git a/net/http2/hpack/decoder/hpack_entry_collector.cc b/net/http2/hpack/decoder/hpack_entry_collector.cc
deleted file mode 100644
index ea4feb6f8475a2307e6142b5c2d0771ea61afd46..0000000000000000000000000000000000000000
--- a/net/http2/hpack/decoder/hpack_entry_collector.cc
+++ /dev/null
@@ -1,317 +0,0 @@
-// 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_entry_collector.h"
-
-#include <sstream>
-#include <string>
-
-#include "base/logging.h"
-#include "net/http2/hpack/decoder/hpack_string_collector.h"
-#include "net/http2/hpack/http2_hpack_constants.h"
-#include "net/http2/tools/failure.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::AssertionResult;
-using std::string;
-using base::StringPiece;
-
-namespace net {
-namespace test {
-namespace {
-
-const HpackEntryType kInvalidHeaderType = static_cast<HpackEntryType>(99);
-const size_t kInvalidIndex = 99999999;
-
-}  // namespace
-
-HpackEntryCollector::HpackEntryCollector() {
-  Clear();
-}
-
-HpackEntryCollector::HpackEntryCollector(const HpackEntryCollector& other)
-    : header_type_(other.header_type_),
-      index_(other.index_),
-      name_(other.name_),
-      value_(other.value_),
-      started_(other.started_),
-      ended_(other.ended_) {}
-
-HpackEntryCollector::HpackEntryCollector(HpackEntryType type,
-                                         size_t index_or_size)
-    : header_type_(type), index_(index_or_size), started_(true), ended_(true) {}
-HpackEntryCollector::HpackEntryCollector(HpackEntryType type,
-                                         size_t index,
-                                         bool value_huffman,
-                                         const string& value)
-    : header_type_(type),
-      index_(index),
-      value_(value, value_huffman),
-      started_(true),
-      ended_(true) {}
-HpackEntryCollector::HpackEntryCollector(HpackEntryType type,
-                                         bool name_huffman,
-                                         const string& name,
-                                         bool value_huffman,
-                                         const string& value)
-    : header_type_(type),
-      index_(0),
-      name_(name, name_huffman),
-      value_(value, value_huffman),
-      started_(true),
-      ended_(true) {}
-
-HpackEntryCollector::~HpackEntryCollector() {}
-
-void HpackEntryCollector::OnIndexedHeader(size_t index) {
-  ASSERT_FALSE(started_);
-  ASSERT_TRUE(IsClear()) << ToString();
-  Init(HpackEntryType::kIndexedHeader, index);
-  ended_ = true;
-}
-void HpackEntryCollector::OnStartLiteralHeader(HpackEntryType header_type,
-                                               size_t maybe_name_index) {
-  ASSERT_FALSE(started_);
-  ASSERT_TRUE(IsClear()) << ToString();
-  Init(header_type, maybe_name_index);
-}
-void HpackEntryCollector::OnNameStart(bool huffman_encoded, size_t len) {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  ASSERT_FALSE(IsClear());
-  ASSERT_TRUE(LiteralNameExpected()) << ToString();
-  name_.OnStringStart(huffman_encoded, len);
-}
-void HpackEntryCollector::OnNameData(const char* data, size_t len) {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  ASSERT_TRUE(LiteralNameExpected()) << ToString();
-  ASSERT_TRUE(name_.IsInProgress());
-  name_.OnStringData(data, len);
-}
-void HpackEntryCollector::OnNameEnd() {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  ASSERT_TRUE(LiteralNameExpected()) << ToString();
-  ASSERT_TRUE(name_.IsInProgress());
-  name_.OnStringEnd();
-}
-void HpackEntryCollector::OnValueStart(bool huffman_encoded, size_t len) {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  if (LiteralNameExpected()) {
-    ASSERT_TRUE(name_.HasEnded());
-  }
-  ASSERT_TRUE(LiteralValueExpected()) << ToString();
-  ASSERT_TRUE(value_.IsClear()) << value_.ToString();
-  value_.OnStringStart(huffman_encoded, len);
-}
-void HpackEntryCollector::OnValueData(const char* data, size_t len) {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  ASSERT_TRUE(LiteralValueExpected()) << ToString();
-  ASSERT_TRUE(value_.IsInProgress());
-  value_.OnStringData(data, len);
-}
-void HpackEntryCollector::OnValueEnd() {
-  ASSERT_TRUE(started_);
-  ASSERT_FALSE(ended_);
-  ASSERT_TRUE(LiteralValueExpected()) << ToString();
-  ASSERT_TRUE(value_.IsInProgress());
-  value_.OnStringEnd();
-  ended_ = true;
-}
-void HpackEntryCollector::OnDynamicTableSizeUpdate(size_t size) {
-  ASSERT_FALSE(started_);
-  ASSERT_TRUE(IsClear()) << ToString();
-  Init(HpackEntryType::kDynamicTableSizeUpdate, size);
-  ended_ = true;
-}
-
-void HpackEntryCollector::Clear() {
-  header_type_ = kInvalidHeaderType;
-  index_ = kInvalidIndex;
-  name_.Clear();
-  value_.Clear();
-  started_ = ended_ = false;
-}
-bool HpackEntryCollector::IsClear() const {
-  return header_type_ == kInvalidHeaderType && index_ == kInvalidIndex &&
-         name_.IsClear() && value_.IsClear() && !started_ && !ended_;
-}
-bool HpackEntryCollector::IsComplete() const {
-  return started_ && ended_;
-}
-bool HpackEntryCollector::LiteralNameExpected() const {
-  switch (header_type_) {
-    case HpackEntryType::kIndexedLiteralHeader:
-    case HpackEntryType::kUnindexedLiteralHeader:
-    case HpackEntryType::kNeverIndexedLiteralHeader:
-      return index_ == 0;
-    default:
-      return false;
-  }
-}
-bool HpackEntryCollector::LiteralValueExpected() const {
-  switch (header_type_) {
-    case HpackEntryType::kIndexedLiteralHeader:
-    case HpackEntryType::kUnindexedLiteralHeader:
-    case HpackEntryType::kNeverIndexedLiteralHeader:
-      return true;
-    default:
-      return false;
-  }
-}
-AssertionResult HpackEntryCollector::ValidateIndexedHeader(
-    size_t expected_index) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(HpackEntryType::kIndexedHeader, header_type_);
-  VERIFY_EQ(expected_index, index_);
-  return ::testing::AssertionSuccess();
-}
-AssertionResult HpackEntryCollector::ValidateLiteralValueHeader(
-    HpackEntryType expected_type,
-    size_t expected_index,
-    bool expected_value_huffman,
-    StringPiece expected_value) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(expected_type, header_type_);
-  VERIFY_NE(0u, expected_index);
-  VERIFY_EQ(expected_index, index_);
-  VERIFY_TRUE(name_.IsClear());
-  VERIFY_SUCCESS(value_.Collected(expected_value, expected_value_huffman));
-  return ::testing::AssertionSuccess();
-}
-AssertionResult HpackEntryCollector::ValidateLiteralNameValueHeader(
-    HpackEntryType expected_type,
-    bool expected_name_huffman,
-    StringPiece expected_name,
-    bool expected_value_huffman,
-    StringPiece expected_value) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(expected_type, header_type_);
-  VERIFY_EQ(0u, index_);
-  VERIFY_SUCCESS(name_.Collected(expected_name, expected_name_huffman));
-  VERIFY_SUCCESS(value_.Collected(expected_value, expected_value_huffman));
-  return ::testing::AssertionSuccess();
-}
-AssertionResult HpackEntryCollector::ValidateDynamicTableSizeUpdate(
-    size_t size) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(HpackEntryType::kDynamicTableSizeUpdate, header_type_);
-  VERIFY_EQ(index_, size);
-  return ::testing::AssertionSuccess();
-}
-
-void HpackEntryCollector::AppendToHpackBlockBuilder(
-    HpackBlockBuilder* hbb) const {
-  ASSERT_TRUE(started_ && ended_) << *this;
-  switch (header_type_) {
-    case HpackEntryType::kIndexedHeader:
-      hbb->AppendIndexedHeader(index_);
-      return;
-
-    case HpackEntryType::kDynamicTableSizeUpdate:
-      hbb->AppendDynamicTableSizeUpdate(index_);
-      return;
-
-    case HpackEntryType::kIndexedLiteralHeader:
-    case HpackEntryType::kUnindexedLiteralHeader:
-    case HpackEntryType::kNeverIndexedLiteralHeader:
-      ASSERT_TRUE(value_.HasEnded()) << *this;
-      if (index_ != 0) {
-        CHECK(name_.IsClear());
-        hbb->AppendNameIndexAndLiteralValue(header_type_, index_,
-                                            value_.huffman_encoded, value_.s);
-      } else {
-        CHECK(name_.HasEnded()) << *this;
-        hbb->AppendLiteralNameAndValue(header_type_, name_.huffman_encoded,
-                                       name_.s, value_.huffman_encoded,
-                                       value_.s);
-      }
-      return;
-
-    default:
-      ADD_FAILURE() << *this;
-  }
-}
-
-string HpackEntryCollector::ToString() const {
-  string result("Type=");
-  switch (header_type_) {
-    case HpackEntryType::kIndexedHeader:
-      result += "IndexedHeader";
-      break;
-    case HpackEntryType::kDynamicTableSizeUpdate:
-      result += "DynamicTableSizeUpdate";
-      break;
-    case HpackEntryType::kIndexedLiteralHeader:
-      result += "IndexedLiteralHeader";
-      break;
-    case HpackEntryType::kUnindexedLiteralHeader:
-      result += "UnindexedLiteralHeader";
-      break;
-    case HpackEntryType::kNeverIndexedLiteralHeader:
-      result += "NeverIndexedLiteralHeader";
-      break;
-    default:
-      if (header_type_ == kInvalidHeaderType) {
-        result += "<unset>";
-      } else {
-        std::stringstream ss;
-        ss << header_type_;
-        result.append(ss.str());
-      }
-  }
-  if (index_ != 0) {
-    result.append(" Index=");
-    std::stringstream ss;
-    ss << index_;
-    result.append(ss.str());
-  }
-  if (!name_.IsClear()) {
-    result.append(" Name");
-    result.append(name_.ToString());
-  }
-  if (!value_.IsClear()) {
-    result.append(" Value");
-    result.append(value_.ToString());
-  }
-  if (!started_) {
-    EXPECT_FALSE(ended_);
-    result.append(" !started");
-  } else if (!ended_) {
-    result.append(" !ended");
-  } else {
-    result.append(" Complete");
-  }
-  return result;
-}
-
-void HpackEntryCollector::Init(HpackEntryType type, size_t maybe_index) {
-  ASSERT_TRUE(IsClear()) << ToString();
-  header_type_ = type;
-  index_ = maybe_index;
-  started_ = true;
-}
-
-bool operator==(const HpackEntryCollector& a, const HpackEntryCollector& b) {
-  return a.name() == b.name() && a.value() == b.value() &&
-         a.index() == b.index() && a.header_type() == b.header_type() &&
-         a.started() == b.started() && a.ended() == b.ended();
-}
-bool operator!=(const HpackEntryCollector& a, const HpackEntryCollector& b) {
-  return !(a == b);
-}
-
-std::ostream& operator<<(std::ostream& out, const HpackEntryCollector& v) {
-  return out << v.ToString();
-}
-
-}  // namespace test
-}  // namespace net