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 <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](

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

I'm curious why "auto validator" became "Validator validator", especially as you
did keep "auto validator" in some other locations (see line 186 below in the
patch set).

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

If I use auto here, I get the compile error below.  I do not understand why.  I
specified Validator where necessary, left auto elsewhere.

../../net/http2/decoder/http2_frame_decoder_test.cc:150:18: error: call to
'ValidateDoneAndEmpty' is ambiguous
        payload, ValidateDoneAndEmpty(validator)));
                 ^~~~~~~~~~~~~~~~~~~~
../../net/http2/tools/failure.h:142:56: note: expanded from macro
'VERIFY_SUCCESS'
  if (::testing::AssertionResult __assertion_result = (expr)) \
                                                       ^~~~
../../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) {
                   ^
../../net/http2/decoder/http2_frame_decoder_test.cc:162:18: error: call to
'ValidateDoneAndOffset' is ambiguous
        payload, ValidateDoneAndOffset(payload.size(), validator)));
                 ^~~~~~~~~~~~~~~~~~~~~
../../net/http2/tools/failure.h:142:56: note: expanded from macro
'VERIFY_SUCCESS'
  if (::testing::AssertionResult __assertion_result = (expr)) \
                                                       ^~~~
../../net/http2/tools/random_decoder_test.h:215:20: note: candidate function
  static Validator ValidateDoneAndOffset(uint32_t offset, Validator wrapped) {
                   ^
../../net/http2/tools/random_decoder_test.h:226:20: note: candidate function
  static Validator ValidateDoneAndOffset(uint32_t offset,
                   ^
2 errors generated.
ninja: build stopped: subcommand failed.

+        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