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

net/http2/decoder/http2_frame_decoder_test.cc

 // 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/decoder/http2_frame_decoder.h"
 
 // Tests of Http2FrameDecoder.
 
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "net/http2/decoder/frame_parts.h"
 #include "net/http2/decoder/frame_parts_collector_listener.h"
 #include "net/http2/http2_constants.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 base::StringPiece;
 using std::string;
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
 
 namespace net {
 namespace test {
 class Http2FrameDecoderPeer {
  public:
   static size_t remaining_total_payload(Http2FrameDecoder* decoder) {
     return decoder->frame_decoder_state_.remaining_total_payload();
   }
 };
 
 namespace {
 
 class Http2FrameDecoderTest : public RandomDecoderTest {
- public:
-  AssertionResult ValidatorForDecodePayloadExpectingError(
-      const FrameParts& expected,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeError);
-    VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
-  }
-
-  AssertionResult ValidatorForBeyondMaximum(const FrameParts& expected,
-                                            const DecodeBuffer& input,
-                                            DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeError);
-    // The decoder detects this error after decoding the header, and without
-    // trying to decode the payload.
-    VERIFY_EQ(input.Offset(), Http2FrameHeader::EncodedSize());
-    VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
-  }
 
  protected:
   void SetUp() override {
     // On any one run of this suite, we'll always choose the same value for
     // use_default_reconstruct_ because the random seed is the same for each
     // test case, but across runs the random seed changes.
     use_default_reconstruct_ = Random().OneIn(2);
   }
 
   DecodeStatus StartDecoding(DecodeBuffer* db) override {
@@ skipping 76 matching lines @@
   }
 
   AssertionResult DecodePayloadAndValidateSeveralWays(StringPiece payload,
                                                       Validator validator) {
     DecodeBuffer db(payload);
     bool start_decoding_requires_non_empty = false;
     return DecodeAndValidateSeveralWays(&db, start_decoding_requires_non_empty,
                                         validator);
   }
 
-  AssertionResult ValidatorForDecodePayloadAndValidateSeveralWays(
-      const FrameParts& expected,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-    VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
-  }
 
   // Decode one frame's payload and confirm that the listener recorded the
   // expected FrameParts instance, and only one 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(
       StringPiece payload,
       const FrameParts& expected) {
-    Validator validator = base::Bind(
-        &Http2FrameDecoderTest::ValidatorForDecodePayloadAndValidateSeveralWays,
-        base::Unretained(this), base::ConstRef(expected));
+    Validator validator = [&expected, this](
+        const DecodeBuffer& input, DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
+    };
     ResetDecodeSpeedCounters();
     VERIFY_SUCCESS(DecodePayloadAndValidateSeveralWays(
         payload, ValidateDoneAndEmpty(validator)));
     VERIFY_GT(fast_decode_count_, 0u);
     VERIFY_GT(slow_decode_count_, 0u);
 
     // Repeat with more input; it should stop without reading that input.
     string next_frame = Random().RandString(10);
     string input;
     payload.AppendToString(&input);
@@ skipping 19 matching lines @@
   AssertionResult DecodePayloadAndValidateSeveralWays(
       const char (&buf)[N],
       const Http2FrameHeader& header) {
     return DecodePayloadAndValidateSeveralWays(StringPiece(buf, N),
                                                FrameParts(header));
   }
 
   template <size_t N>
   AssertionResult DecodePayloadExpectingError(const char (&buf)[N],
                                               const FrameParts& expected) {
+    auto validator = [&expected, this](const DecodeBuffer& input,
+                                       DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeError);
+      VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
+    };
     ResetDecodeSpeedCounters();
-    EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(
-        ToStringPiece(buf),
-        base::Bind(
-            &Http2FrameDecoderTest::ValidatorForDecodePayloadExpectingError,
-            base::Unretained(this), expected)));
+    EXPECT_TRUE(
+        DecodePayloadAndValidateSeveralWays(ToStringPiece(buf), validator));
     EXPECT_GT(fast_decode_count_, 0u);
     EXPECT_GT(slow_decode_count_, 0u);
     return AssertionSuccess();
   }
 
   template <size_t N>
   AssertionResult DecodePayloadExpectingFrameSizeError(const char (&buf)[N],
                                                        FrameParts expected) {
     expected.has_frame_size_error = true;
     VERIFY_AND_RETURN_SUCCESS(DecodePayloadExpectingError(buf, expected));
@@ skipping 630 matching lines @@
       0x00, 0x00, 0x00, 0x02,  // Stream ID: 0  (REQUIRES ID)
       0x03,                    // Pad Len
       'a',  'b',  'c',         // Data
       0x00, 0x00, 0x00,        // Padding
   };
   Http2FrameHeader header(
       7, Http2FrameType::DATA,
       Http2FrameFlag::FLAG_END_STREAM | Http2FrameFlag::FLAG_PADDED, 2);
   FrameParts expected(header);
   expected.has_frame_size_error = true;
+  auto validator = [&expected, this](const DecodeBuffer& input,
+                                     DecodeStatus status) -> AssertionResult {
+    VERIFY_EQ(status, DecodeStatus::kDecodeError);
+    // The decoder detects this error after decoding the header, and without
+    // trying to decode the payload.
+    VERIFY_EQ(input.Offset(), Http2FrameHeader::EncodedSize());
+    VERIFY_AND_RETURN_SUCCESS(VerifyCollected(expected));
+  };
   ResetDecodeSpeedCounters();
-  EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(
-      ToStringPiece(kFrameData),
-      base::Bind(&Http2FrameDecoderTest::ValidatorForBeyondMaximum,
-                 base::Unretained(this), expected)));
+  EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(ToStringPiece(kFrameData),
+                                                  validator));
   EXPECT_GT(fast_decode_count_, 0u);
   EXPECT_GT(slow_decode_count_, 0u);
 }
 
 TEST_F(Http2FrameDecoderTest, PriorityTooLong) {
   const char kFrameData[] = {
       0x00,  0x00, 0x06,        // Length: 5
       0x02,                     //   Type: PRIORITY
       0x00,                     //  Flags: none
       0x00,  0x00, 0x00, 0x02,  // Stream: 2
@@ skipping 55 matching lines @@
       0x80u, 0x00, 0x04, 0x00,  //   Incr: 1024 (plus R bit)
       0x00,                     // Too much
   };
   Http2FrameHeader header(5, Http2FrameType::WINDOW_UPDATE, 0, 1);
   EXPECT_TRUE(DecodePayloadExpectingFrameSizeError(kFrameData, header));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net