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

net/http2/tools/random_decoder_test.h

Index: net/http2/tools/random_decoder_test.h
diff --git a/net/http2/tools/random_decoder_test.h b/net/http2/tools/random_decoder_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..f3ab829d8067c64dddd2fe5a507b9ea90b661b95
--- /dev/null
+++ b/net/http2/tools/random_decoder_test.h
@@ -0,0 +1,264 @@
+// 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.
+
+#ifndef NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
+#define NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
+
+// RandomDecoderTest is a base class for tests of decoding various kinds
+// of HTTP/2 and HPACK encodings.
+
+// TODO(jamessynge): Move more methods into .cc file.
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <type_traits>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+#include "base/template_util.h"
+#include "net/http2/decoder/decode_buffer.h"
+#include "net/http2/decoder/decode_status.h"
+#include "net/http2/tools/failure.h"
+#include "net/http2/tools/http2_random.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace test {
+
+// Some helpers.
+
+template <typename T, size_t N>
+base::StringPiece ToStringPiece(T (&data)[N]) {
+  return base::StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T));
+}
+
+// strings/hex_ascii_dump.h doesn't support StringPiece args for this case.
+std::string HexEncode(base::StringPiece s);
+
+// Overwrite the enum with some random value, probably not a valid value for
+// the enum type, but which fits into its storage.
+template <typename T,
+          typename E = typename std::enable_if<std::is_enum<T>::value>::type>
+void CorruptEnum(T* out, RandomBase* rng) {
+  // Per cppreference.com, if the destination type of a static_cast is
+  // smaller than the source type (i.e. type of r and uint32 below), the
+  // resulting value is the smallest unsigned value equal to the source value
+  // modulo 2^n, where n is the number of bits used to represent the
+  // destination type unsigned U.
+  typedef typename base::underlying_type<T>::type underlying_type_T;
+  typedef typename std::make_unsigned<underlying_type_T>::type
+      unsigned_underlying_type_T;
+  auto r = static_cast<unsigned_underlying_type_T>(rng->Rand32());
+  *out = static_cast<T>(r);
+}
+
+// Base class for tests of the ability to decode a sequence of bytes with
+// various boundaries between the DecodeBuffers provided to the decoder.
+class RandomDecoderTest : public ::testing::Test {
+ public:
+  // SelectSize returns the size of the next DecodeBuffer to be passed to the
+  // decoder. Note that RandomDecoderTest allows that size to be zero, though
+  // some decoders can't deal with that on the first byte, hence the |first|
+  // parameter.
+  typedef base::Callback<size_t(bool first, size_t offset, size_t remaining)>
+      SelectSize;
+
+  // Validator returns an AssertionResult so test can do:
+  // EXPECT_THAT(DecodeAndValidate(..., validator));
+  typedef ::testing::AssertionResult AssertionResult;
+  typedef base::Callback<AssertionResult(const DecodeBuffer& input,
+                                         DecodeStatus status)>
+      Validator;
+  typedef base::Callback<AssertionResult()> NoArgValidator;
+
+  RandomDecoderTest();
+
+ protected:
+  // TODO(jamessynge): Modify StartDecoding, etc. to (somehow) return
+  // AssertionResult so that the VERIFY_* methods exported from
+  // gunit_helpers.h can be widely used.
+
+  // Start decoding; call allows sub-class to Reset the decoder, or deal with
+  // the first byte if that is done in a unique fashion.  Might be called with
+  // a zero byte buffer.
+  virtual DecodeStatus StartDecoding(DecodeBuffer* db) = 0;
+
+  // Resume decoding of the input after a prior call to StartDecoding, and
+  // possibly many calls to ResumeDecoding.
+  virtual DecodeStatus ResumeDecoding(DecodeBuffer* db) = 0;
+
+  // Return true if a decode status of kDecodeDone indicates that
+  // decoding should stop.
+  virtual bool StopDecodeOnDone();
+
+  // Decode buffer |original| until we run out of input, or kDecodeDone is
+  // returned by the decoder AND StopDecodeOnDone() returns true. Segments
+  // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers
+  // by calling |select_size| to decide how large each buffer should be.
+  // We do this to test the ability to deal with arbitrary boundaries, as might
+  // happen in transport.
+  // Returns the final DecodeStatus.
+  DecodeStatus DecodeSegments(DecodeBuffer* original,
+                              const SelectSize& select_size);
+
+  // Decode buffer |original| until we run out of input, or kDecodeDone is
+  // returned by the decoder AND StopDecodeOnDone() returns true. Segments
+  // (i.e. cuts up) the original DecodeBuffer into (potentially) smaller buffers
+  // by calling |select_size| to decide how large each buffer should be.
+  // We do this to test the ability to deal with arbitrary boundaries, as might
+  // happen in transport.
+  // Invokes |validator| with the final decode status and the original decode
+  // buffer, with the cursor advanced as far as has been consumed by the decoder
+  // and returns validator's result.
+  ::testing::AssertionResult DecodeSegmentsAndValidate(
+      DecodeBuffer* original,
+      const SelectSize& select_size,
+      const Validator& validator) {
+    DecodeStatus status = DecodeSegments(original, select_size);
+    VERIFY_AND_RETURN_SUCCESS(validator.Run(*original, status));
+  }
+
+  // Returns a size for fast decoding, i.e. passing all that
+  // is available to the decoder.
+  static size_t SelectRemaining(bool first, size_t offset, size_t remaining) {
+    return remaining;
+  }
+
+  // Returns a size for decoding a single byte at a time.
+  static size_t SelectOne(bool first, size_t offset, size_t remaining) {
+    return 1;
+  }
+
+  // Returns a size for decoding a single byte at a time, where
+  // zero byte buffers are also allowed. Alternates between zero and one.
+  static size_t SelectZeroAndOne(bool* zero_next,
+                                 bool first,
+                                 size_t offset,
+                                 size_t remaining);
+
+  // Returns a size for decoding random sized segments.
+  size_t SelectRandom(bool return_non_zero_on_first,
+                      bool first,
+                      size_t offset,
+                      size_t remaining);
+
+  // Decode |original| multiple times, with different segmentations of the
+  // decode buffer, validating after each decode, and confirming that they
+  // each decode the same amount. Returns on the first failure, else returns
+  // success.
+  AssertionResult DecodeAndValidateSeveralWays(DecodeBuffer* original,
+                                               bool return_non_zero_on_first,
+                                               const Validator& validator);
+
+  static AssertionResult SucceedingValidator(const DecodeBuffer& input,
+                                             DecodeStatus status) {
+    return ::testing::AssertionSuccess();
+  }
+
+  static Validator ToValidator(const Validator& validator) { return validator; }
+
+  static AssertionResult RunNoArgValidator(const NoArgValidator& validator,
+                                           const DecodeBuffer& input,
+                                           DecodeStatus status) {
+    return validator.Run();
+  }
+
+  static Validator ToValidator(const NoArgValidator& validator) {
+    return base::Bind(&RunNoArgValidator, validator);
+  }
+
+  // Wraps a validator with another validator
+  // that first checks that the DecodeStatus is kDecodeDone and
+  // that the DecodeBuffer is empty.
+  // TODO(jamessynge): Replace this overload with the next, as using this method
+  // usually means that the wrapped function doesn't need to be passed the
+  // DecodeBuffer nor the DecodeStatus.
+  static AssertionResult ValidateDoneAndEmptyImpl(const Validator& wrapped,
+                                                  const DecodeBuffer& input,
+                                                  DecodeStatus status) {
+    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+    VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+    return wrapped.Run(input, status);
+  }
+  static Validator ValidateDoneAndEmpty(const Validator& wrapped) {
+    return base::Bind(&ValidateDoneAndEmptyImpl, wrapped);
+  }
+  static AssertionResult ValidateDoneAndEmptyNoArgImpl(
+      const NoArgValidator& wrapped,
+      const DecodeBuffer& input,
+      DecodeStatus status) {
+    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+    VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+    return wrapped.Run();
+  }
+  static Validator ValidateDoneAndEmpty(const NoArgValidator& wrapped) {
+    return base::Bind(&ValidateDoneAndEmptyNoArgImpl, wrapped);
+  }
+  static Validator ValidateDoneAndEmpty() {
+    return ValidateDoneAndEmpty(base::Bind(&SucceedingValidator));
+  }
+
+  // Wraps a validator with another validator
+  // that first checks that the DecodeStatus is kDecodeDone and
+  // that the DecodeBuffer has the expected offset.
+  // TODO(jamessynge): Replace this overload with the next, as using this method
+  // usually means that the wrapped function doesn't need to be passed the
+  // DecodeBuffer nor the DecodeStatus.
+  static AssertionResult ValidateDoneAndOffsetImpl(uint32_t offset,
+                                                   const Validator& wrapped,
+                                                   const DecodeBuffer& input,
+                                                   DecodeStatus status) {
+    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+    VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+    return wrapped.Run(input, status);
+  }
+  static Validator ValidateDoneAndOffset(uint32_t offset,
+                                         const Validator& wrapped) {
+    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
+    // issues if this method is called with a temporary Validator.
+    return base::Bind(&ValidateDoneAndOffsetImpl, offset, wrapped);
+  }
+  static AssertionResult ValidateDoneAndOffsetNoArgImpl(
+      uint32_t offset,
+      const NoArgValidator& wrapped,
+      const DecodeBuffer& input,
+      DecodeStatus status) {
+    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+    VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+    return wrapped.Run();
+  }
+  static Validator ValidateDoneAndOffset(uint32_t offset,
+                                         const NoArgValidator& wrapped) {
+    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
+    // issues if this method is called with a temporary Validator.
+    return base::Bind(&ValidateDoneAndOffsetNoArgImpl, offset, wrapped);
+  }
+  static Validator ValidateDoneAndOffset(uint32_t offset) {
+    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
+    // issues if this method is called with a temporary Validator.
+    return ValidateDoneAndOffset(offset, base::Bind(&SucceedingValidator));
+  }
+
+  // Expose |random_| as RandomBase so callers do not have to care about which
+  // sub-class of RandomBase is used, nor can they rely on the specific
+  // sub-class that RandomDecoderTest uses.
+  RandomBase& Random() { return random_; }
+  RandomBase* RandomPtr() { return &random_; }
+
+  uint32_t RandStreamId();
+
+  bool stop_decode_on_done_ = true;
+
+ private:
+  Http2Random random_;
+};
+
+}  // namespace test
+}  // namespace net
+
+#endif  // NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_