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

net/http2/hpack/decoder/hpack_string_decoder_test.cc

Index: net/http2/hpack/decoder/hpack_string_decoder_test.cc
diff --git a/net/http2/hpack/decoder/hpack_string_decoder_test.cc b/net/http2/hpack/decoder/hpack_string_decoder_test.cc
deleted file mode 100644
index e4afc61e4e74bb3a02c34877e6cd534e435a5c85..0000000000000000000000000000000000000000
--- a/net/http2/hpack/decoder/hpack_string_decoder_test.cc
+++ /dev/null
@@ -1,194 +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_string_decoder.h"
-
-// Tests of HpackStringDecoder.
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/strings/string_piece.h"
-#include "net/http2/hpack/decoder/hpack_string_collector.h"
-#include "net/http2/hpack/decoder/hpack_string_decoder_listener.h"
-#include "net/http2/hpack/tools/hpack_block_builder.h"
-#include "net/http2/tools/failure.h"
-#include "net/http2/tools/http2_random.h"
-#include "net/http2/tools/random_decoder_test.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::AssertionResult;
-using ::testing::AssertionSuccess;
-using base::StringPiece;
-using std::string;
-
-namespace net {
-namespace test {
-namespace {
-
-const bool kMayReturnZeroOnFirst = false;
-const bool kCompressed = true;
-const bool kUncompressed = false;
-
-enum StartMethod {
-  kStart,
-  kStartOnly,
-  kStartAndDecodeLength,
-  kStartSpecialCaseShort,
-};
-
-class HpackStringDecoderTest
-    : public RandomDecoderTest,
-      public ::testing::WithParamInterface<StartMethod> {
- protected:
-  HpackStringDecoderTest()
-      : start_method_(GetParam()), listener_(&collector_) {}
-
-  DecodeStatus StartDecoding(DecodeBuffer* b) override {
-    ++start_decoding_calls_;
-    collector_.Clear();
-    switch (start_method_) {
-      case kStart:
-        return decoder_.Start(b, &listener_);
-      case kStartOnly:
-        return decoder_.StartOnly(b, &listener_);
-      case kStartAndDecodeLength:
-        return decoder_.StartAndDecodeLength(b, &listener_);
-      case kStartSpecialCaseShort:
-        return decoder_.StartSpecialCaseShort(b, &listener_);
-      default:
-        return DecodeStatus::kDecodeError;
-    }
-  }
-
-  DecodeStatus ResumeDecoding(DecodeBuffer* b) override {
-    // Provides coverage of DebugString and StateToString.
-    // Not validating output.
-    VLOG(1) << decoder_.DebugString();
-    VLOG(2) << collector_;
-    return decoder_.Resume(b, &listener_);
-  }
-
-  AssertionResult Collected(StringPiece s, bool huffman_encoded) {
-    VLOG(1) << collector_;
-    return collector_.Collected(s, huffman_encoded);
-  }
-
-  // Note that base::Bind() makes a copy of |expected_str| even though it is
-  // taken as a constant reference, so even if MakeValidator is called with a
-  // C-style string that is cast to a temporary std::string that gets destroyed
-  // after the call to MakeValidator, |expected_str| is still valid later when
-  // the Validator is run.
-  AssertionResult StringValidator(const string& expected_str,
-                                  bool expected_huffman,
-                                  const DecodeBuffer& input,
-                                  DecodeStatus status) {
-    AssertionResult result = Collected(expected_str, expected_huffman);
-    if (result) {
-      VERIFY_EQ(collector_,
-                HpackStringCollector(expected_str, expected_huffman));
-    } else {
-      VERIFY_NE(collector_,
-                HpackStringCollector(expected_str, expected_huffman));
-    }
-    VLOG(2) << collector_.ToString();
-    collector_.Clear();
-    VLOG(2) << collector_;
-    return result;
-  }
-
-  Validator MakeValidator(const string& expected_str, bool expected_huffman) {
-    return base::Bind(&HpackStringDecoderTest::StringValidator,
-                      base::Unretained(this), expected_str, expected_huffman);
-  }
-
-  const StartMethod start_method_;
-  HpackStringDecoder decoder_;
-  HpackStringCollector collector_;
-  HpackStringDecoderVLoggingListener listener_;
-  size_t start_decoding_calls_ = 0;
-};
-
-TEST_P(HpackStringDecoderTest, DecodeEmptyString) {
-  {
-    Validator validator = ValidateDoneAndEmpty(MakeValidator("", kCompressed));
-    const char kData[] = {0x80u};
-    DecodeBuffer b(kData);
-    EXPECT_TRUE(
-        DecodeAndValidateSeveralWays(&b, kMayReturnZeroOnFirst, validator));
-  }
-  {
-    // Make sure it stops after decoding the empty string.
-    Validator validator =
-        ValidateDoneAndOffset(1, MakeValidator("", kUncompressed));
-    const char kData[] = {0x00, 0xffu};
-    DecodeBuffer b(kData);
-    EXPECT_EQ(2u, b.Remaining());
-    EXPECT_TRUE(
-        DecodeAndValidateSeveralWays(&b, kMayReturnZeroOnFirst, validator));
-    EXPECT_EQ(1u, b.Remaining());
-  }
-}
-
-TEST_P(HpackStringDecoderTest, DecodeShortString) {
-  {
-    // Make sure it stops after decoding the non-empty string.
-    Validator validator =
-        ValidateDoneAndOffset(11, MakeValidator("start end.", kCompressed));
-    const char kData[] = "\x8astart end.Don't peek at this.";
-    DecodeBuffer b(kData);
-    EXPECT_TRUE(
-        DecodeAndValidateSeveralWays(&b, kMayReturnZeroOnFirst, validator));
-  }
-  {
-    Validator validator =
-        ValidateDoneAndOffset(11, MakeValidator("start end.", kUncompressed));
-    StringPiece data("\x0astart end.");
-    DecodeBuffer b(data);
-    EXPECT_TRUE(
-        DecodeAndValidateSeveralWays(&b, kMayReturnZeroOnFirst, validator));
-  }
-}
-
-TEST_P(HpackStringDecoderTest, DecodeLongStrings) {
-  string name = Random().RandString(1024);
-  string value = Random().RandString(65536);
-  HpackBlockBuilder hbb;
-
-  hbb.AppendString(false, name);
-  uint32_t offset_after_name = hbb.size();
-  EXPECT_EQ(3 + name.size(), offset_after_name);
-
-  hbb.AppendString(true, value);
-  uint32_t offset_after_value = hbb.size();
-  EXPECT_EQ(3 + name.size() + 4 + value.size(), offset_after_value);
-
-  DecodeBuffer b(hbb.buffer());
-
-  // Decode the name...
-  EXPECT_TRUE(DecodeAndValidateSeveralWays(
-      &b, kMayReturnZeroOnFirst,
-      ValidateDoneAndOffset(offset_after_name,
-                            MakeValidator(name, kUncompressed))));
-  EXPECT_EQ(offset_after_name, b.Offset());
-  EXPECT_EQ(offset_after_value - offset_after_name, b.Remaining());
-
-  // Decode the value...
-  EXPECT_TRUE(DecodeAndValidateSeveralWays(
-      &b, kMayReturnZeroOnFirst,
-      ValidateDoneAndOffset(offset_after_value - offset_after_name,
-                            MakeValidator(value, kCompressed))));
-  EXPECT_EQ(offset_after_value, b.Offset());
-  EXPECT_EQ(0u, b.Remaining());
-}
-
-INSTANTIATE_TEST_CASE_P(AllStartMethods,
-                        HpackStringDecoderTest,
-                        ::testing::Values(kStart,
-                                          kStartOnly,
-                                          kStartAndDecodeLength,
-                                          kStartSpecialCaseShort));
-
-}  // namespace
-}  // namespace test
-}  // namespace net