Use std::function instead of base::Callback in net/http2/.

net/http2/decoder/payload_decoders/payload_decoder_base_test_util.h

 // 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_DECODER_PAYLOAD_DECODERS_PAYLOAD_DECODER_BASE_TEST_UTIL_H_
 #define NET_HTTP2_DECODER_PAYLOAD_DECODERS_PAYLOAD_DECODER_BASE_TEST_UTIL_H_
 
 // Base class for testing concrete payload decoder classes.
 
 #include <stddef.h>
 
 #include <string>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "net/http2/decoder/decode_buffer.h"
 #include "net/http2/decoder/decode_status.h"
 #include "net/http2/decoder/frame_decoder_state.h"
 #include "net/http2/decoder/frame_parts.h"
 #include "net/http2/decoder/http2_frame_decoder_listener.h"
 #include "net/http2/http2_constants.h"
 #include "net/http2/http2_constants_test_util.h"
 #include "net/http2/http2_structures.h"
@@ skipping 89 matching lines @@
 // Base class for payload decoders of type Decoder, with corresponding test
 // peer of type DecoderPeer, and using class Listener as the implementation
 // of Http2FrameDecoderListenerInterface to be used during decoding.
 // Typically Listener is a sub-class of FramePartsCollector.
 // SupportedFrameType is set to false only for UnknownPayloadDecoder.
 template <class Decoder,
           class DecoderPeer,
           class Listener,
           bool SupportedFrameType = true>
 class AbstractPayloadDecoderTest : public PayloadDecoderBaseTest {
- public:
-  static bool SucceedingApproveSize(size_t size) { return true; }
 
  protected:
   // An ApproveSize function returns true to approve decoding the specified
   // size of payload, else false to skip that size. Typically used for negative
   // tests; for example, decoding a SETTINGS frame at all sizes except for
   // multiples of 6.
-  typedef base::Callback<bool(size_t size)> ApproveSize;
+  typedef std::function<bool(size_t size)> ApproveSize;
 
   AbstractPayloadDecoderTest() {}
 
   // These tests are in setup rather than the constructor for two reasons:
   // 1) Constructors are not allowed to fail, so gUnit documents that EXPECT_*
   //    and ASSERT_* are not allowed in constructors, and should instead be in
   //    SetUp if they are needed before the body of the test is executed.
   // 2) To allow the sub-class constructor to make any desired modifications to
   //    the DecoderPeer before these tests are executed; in particular,
   //    UnknownPayloadDecoderPeer has not got a fixed frame type, but it is
   //    instead set during the test's constructor.
   void SetUp() override {
     PayloadDecoderBaseTest::SetUp();
 
     // Confirm that DecoderPeer et al returns sensible values. Using auto as the
     // variable type so that no (narrowing) conversions take place that hide
     // problems; i.e. if someone changes KnownFlagsMaskForFrameType so that it
     // doesn't return a uint8, and has bits above the low-order 8 bits set, this
     // bit of paranoia should detect the problem before we get too far.
     auto frame_type = DecoderPeer::FrameType();
     if (SupportedFrameType) {

[James Synge, 2017/01/05 21:39:06]

I don't recall if we discussed this, but why is this block not:

    EXPECT_EQ(SupportedFrameType, IsSupportedHttp2FrameType(frame_type))
        << frame_type;

[Bence, 2017/01/06 01:42:40]

This was changed server side at change 134543154.  But unfortunately I do not
remember why this had to be so contrived.  It compiles for me locally.  Let's
revisit this in a separate CL.

       EXPECT_TRUE(IsSupportedHttp2FrameType(frame_type)) << frame_type;
     } else {
       EXPECT_FALSE(IsSupportedHttp2FrameType(frame_type)) << frame_type;
     }
 
     auto known_flags = KnownFlagsMaskForFrameType(frame_type);
     EXPECT_EQ(known_flags, known_flags & 0xff);
 
     auto flags_to_avoid = DecoderPeer::FlagsAffectingPayloadDecoding();
     EXPECT_EQ(flags_to_avoid, flags_to_avoid & known_flags);
@@ skipping 23 matching lines @@
     DVLOG(2) << "StartDecodingPayload, db->Remaining=" << db->Remaining();
     return payload_decoder_.StartDecodingPayload(mutable_state(), db);
   }
 
   // Resume decoding the payload.
   DecodeStatus ResumeDecodingPayload(DecodeBuffer* db) override {
     DVLOG(2) << "ResumeDecodingPayload, db->Remaining=" << db->Remaining();
     return payload_decoder_.ResumeDecodingPayload(mutable_state(), db);
   }
 
-  // Wrap |validator| in another one which will check that we've reached the
-  // expected state of kDecodeError with OnFrameSizeError having been called by
-  AssertionResult ValidatorForDecodePayloadAndValidateSeveralWays(
-      const FrameParts& expected) {
-    VERIFY_FALSE(listener_.IsInProgress());
-    VERIFY_EQ(1u, listener_.size());
-    VERIFY_AND_RETURN_SUCCESS(expected.VerifyEquals(*listener_.frame(0)));
-  }
 
   // Decode one frame's payload and confirm that the listener recorded the
   // expected FrameParts instance, and only FrameParts instance. The payload
   // will be decoded several times with different partitionings of the payload,
   // and after each the validator will be called.
   AssertionResult DecodePayloadAndValidateSeveralWays(
       base::StringPiece payload,
       const FrameParts& expected) {
+    NoArgValidator validator = [&expected, this]() -> AssertionResult {

[James Synge, 2017/01/05 21:39:06]

auto validator?

[Bence, 2017/01/06 01:42:40]

../../net/http2/decoder/payload_decoders/payload_decoder_base_test_util.h:208:18:
error: call to 'ValidateDoneAndEmpty' is ambiguous
        payload, ValidateDoneAndEmpty(validator));
                 ^~~~~~~~~~~~~~~~~~~~
../../net/http2/decoder/payload_decoders/priority_payload_decoder_test.cc:89:17:
note: in instantiation of member function
'net::test::AbstractPayloadDecoderTest<net::PriorityPayloadDecoder,
net::test::PriorityPayloadDecoderPeer, net::test::(anonymous
namespace)::Listener, true>::DecodePayloadAndValidateSeveralWays' requested here
    EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
                ^
../../net/http2/tools/random_decoder_test.h:182:20: note: candidate function
  static Validator ValidateDoneAndEmpty(const Validator& wrapped) {
                   ^
../../net/http2/tools/random_decoder_test.h:193:20: note: candidate function
  static Validator ValidateDoneAndEmpty(NoArgValidator wrapped) {
                   ^
1 error generated.

+      VERIFY_FALSE(listener_.IsInProgress());
+      VERIFY_EQ(1u, listener_.size());
+      VERIFY_AND_RETURN_SUCCESS(expected.VerifyEquals(*listener_.frame(0)));
+    };
     return PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
-        payload, this->ValidateDoneAndEmpty(base::Bind(
-                     &AbstractPayloadDecoderTest::
-                         ValidatorForDecodePayloadAndValidateSeveralWays,
-                     base::Unretained(this), base::ConstRef(expected))));
-  }
-
-  // Wrap |validator| in another one which will check that we've reached the
-  // expected state of kDecodeError with OnFrameSizeError having been called by
-  // the payload decoder.
-  AssertionResult ValidatorForVerifyDetectsFrameSizeError(
-      const Http2FrameHeader& header,
-      const Validator& validator,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    DVLOG(2) << "VerifyDetectsFrameSizeError validator; status=" << status
-             << "; input.Remaining=" << input.Remaining();
-    VERIFY_EQ(DecodeStatus::kDecodeError, status);
-    VERIFY_FALSE(listener_.IsInProgress());
-    VERIFY_EQ(1u, listener_.size());
-    const FrameParts* frame = listener_.frame(0);
-    VERIFY_EQ(header, frame->frame_header);
-    VERIFY_TRUE(frame->has_frame_size_error);
-    // Verify did not get OnPaddingTooLong, as we should only ever produce
-    // one of these two errors for a single frame.
-    VERIFY_FALSE(frame->opt_missing_length);
-    return validator.Run(input, status);
+        payload, ValidateDoneAndEmpty(validator));
   }
 
   // Decode one frame's payload, expecting that the final status will be
   // kDecodeError, and that OnFrameSizeError will have been called on the
   // listener. The payload will be decoded several times with different
   // partitionings of the payload. The type WrappedValidator is either
   // RandomDecoderTest::Validator, RandomDecoderTest::NoArgValidator or
   // std::nullptr_t (not extra validation).
   template <typename WrappedValidator>
   ::testing::AssertionResult VerifyDetectsFrameSizeError(
       base::StringPiece payload,
       const Http2FrameHeader& header,
       WrappedValidator wrapped_validator) {
     set_frame_header(header);
     // If wrapped_validator is not a RandomDecoderTest::Validator, make it so.
-    Validator validator = this->ToValidator(wrapped_validator);
+    Validator validator = ToValidator(wrapped_validator);
+    // And wrap that validator in another which will check that we've reached
+    // the expected state of kDecodeError with OnFrameSizeError having been
+    // called by the payload decoder.
+    validator = [header, validator, this](
+        const DecodeBuffer& input,
+        DecodeStatus status) -> ::testing::AssertionResult {
+      DVLOG(2) << "VerifyDetectsFrameSizeError validator; status=" << status
+               << "; input.Remaining=" << input.Remaining();
+      VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      VERIFY_FALSE(listener_.IsInProgress());
+      VERIFY_EQ(1u, listener_.size());
+      const FrameParts* frame = listener_.frame(0);
+      VERIFY_EQ(header, frame->frame_header);
+      VERIFY_TRUE(frame->has_frame_size_error);
+      // Verify did not get OnPaddingTooLong, as we should only ever produce
+      // one of these two errors for a single frame.
+      VERIFY_FALSE(frame->opt_missing_length);
+      return validator(input, status);
+    };
     VERIFY_AND_RETURN_SUCCESS(
-        PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
-            payload, base::Bind(&AbstractPayloadDecoderTest::
-                                    ValidatorForVerifyDetectsFrameSizeError,
-                                base::Unretained(this), base::ConstRef(header),
-                                base::ConstRef(validator))));
+        PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(payload,
+                                                                    validator));
   }
 
   // Confirm that we get OnFrameSizeError when trying to decode unpadded_payload
   // at all sizes from zero to unpadded_payload.size(), except those sizes not
   // approved by approve_size.
   // If total_pad_length is greater than zero, then that amount of padding
   // is added to the payload (including the Pad Length field).
   // The flags will be required_flags, PADDED if total_pad_length > 0, and some
   // randomly selected flag bits not excluded by FlagsAffectingPayloadDecoding.
   ::testing::AssertionResult VerifyDetectsMultipleFrameSizeErrors(
@@ skipping 18 matching lines @@
       } else {
         required_flags |= Http2FrameFlag::FLAG_PADDED;
       }
     } else {
       VERIFY_EQ(0, total_pad_length);
     }
 
     bool validated = false;
     for (size_t real_payload_size = 0;
          real_payload_size <= unpadded_payload.size(); ++real_payload_size) {
-      if (!approve_size.Run(real_payload_size)) {
+      if (approve_size != nullptr && !approve_size(real_payload_size)) {
         continue;
       }
       VLOG(1) << "real_payload_size=" << real_payload_size;
       uint8_t flags = required_flags | RandFlags();
       Http2FrameBuilder fb;
       if (total_pad_length > 0) {
         // total_pad_length_ includes the size of the Pad Length field, and thus
         // ranges from 0 (no PADDED flag) to 256 (Pad Length == 255).
         fb.AppendUInt8(total_pad_length - 1);
       }
       // Append a subset of the unpadded_payload, which the decoder should
       // determine is not a valid amount.
       fb.Append(unpadded_payload.substr(0, real_payload_size));
       if (total_pad_length > 0) {
         fb.AppendZeroes(total_pad_length - 1);
       }
       // We choose a random stream id because the payload decoders aren't
       // checking stream ids.
       uint32_t stream_id = RandStreamId();
       Http2FrameHeader header(fb.size(), frame_type, flags, stream_id);
-      VERIFY_SUCCESS(VerifyDetectsFrameSizeError(
-          fb.buffer(), header, base::Bind(&SucceedingValidator)));
+      VERIFY_SUCCESS(VerifyDetectsFrameSizeError(fb.buffer(), header, nullptr));
       validated = true;
     }
     VERIFY_TRUE(validated);
     return ::testing::AssertionSuccess();
   }
 
   // As above, but for frames without padding.
   ::testing::AssertionResult VerifyDetectsFrameSizeError(
       uint8_t required_flags,
       base::StringPiece unpadded_payload,
@@ skipping 64 matching lines @@
   uint8_t RandFlags() {
     uint8_t flags = Base::RandFlags();
     if (IsPadded()) {
       flags |= Http2FrameFlag::FLAG_PADDED;
     } else {
       flags &= ~Http2FrameFlag::FLAG_PADDED;
     }
     return flags;
   }
 
-  static ::testing::AssertionResult ValidatorForVerifyDetectsPaddingTooLong(
-      const Http2FrameHeader& header,
-      int expected_missing_length,
-      const Listener& listener,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    VERIFY_EQ(DecodeStatus::kDecodeError, status);
-    VERIFY_FALSE(listener.IsInProgress());
-    VERIFY_EQ(1u, listener.size());
-    const FrameParts* frame = listener.frame(0);
-    VERIFY_EQ(header, frame->frame_header);
-    VERIFY_TRUE(frame->opt_missing_length);
-    VERIFY_EQ(expected_missing_length, frame->opt_missing_length.value());
-    // Verify did not get OnFrameSizeError.
-    VERIFY_FALSE(frame->has_frame_size_error);
-    return ::testing::AssertionSuccess();
-  }
 
   // Verify that we get OnPaddingTooLong when decoding payload, and that the
   // amount of missing padding is as specified. header.IsPadded must be true,
   // and the payload must be empty or the PadLength field must be too large.
   ::testing::AssertionResult VerifyDetectsPaddingTooLong(
       base::StringPiece payload,
       const Http2FrameHeader& header,
       int expected_missing_length) {
     set_frame_header(header);
     auto& listener = listener_;
+    Validator validator = [header, expected_missing_length, &listener](
+        const DecodeBuffer& input,
+        DecodeStatus status) -> ::testing::AssertionResult {
+      VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      VERIFY_FALSE(listener.IsInProgress());
+      VERIFY_EQ(1u, listener.size());
+      const FrameParts* frame = listener.frame(0);
+      VERIFY_EQ(header, frame->frame_header);
+      VERIFY_TRUE(frame->opt_missing_length);
+      VERIFY_EQ(expected_missing_length, frame->opt_missing_length.value());
+      // Verify did not get OnFrameSizeError.
+      VERIFY_FALSE(frame->has_frame_size_error);
+      return ::testing::AssertionSuccess();
+    };
     VERIFY_AND_RETURN_SUCCESS(
-        PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
-            payload, base::Bind(&AbstractPaddablePayloadDecoderTest::
-                                    ValidatorForVerifyDetectsPaddingTooLong,
-                                header, expected_missing_length,
-                                base::ConstRef(listener))));
+        PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(payload,
+                                                                    validator));
   }
 
   // Verifies that we get OnPaddingTooLong for a padded frame payload whose
   // (randomly selected) payload length is less than total_pad_length_.
   // Flags will be selected at random, except PADDED will be set and
   // flags_to_avoid will not be set. The stream id is selected at random.
   ::testing::AssertionResult VerifyDetectsPaddingTooLong() {
     uint8_t flags = RandFlags() | Http2FrameFlag::FLAG_PADDED;
 
     // Create an all padding payload for total_pad_length_.
@@ skipping 25 matching lines @@
   // total_pad_length_ includes the size of the Pad Length field, and thus
   // ranges from 0 (no PADDED flag) to 256 (Pad Length == 255).
   const size_t total_pad_length_;
   Http2FrameBuilder frame_builder_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_HTTP2_DECODER_PAYLOAD_DECODERS_PAYLOAD_DECODER_BASE_TEST_UTIL_H_