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

net/http2/decoder/decode_http2_structures_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/decode_http2_structures.h"
 
 // Tests decoding all of the fixed size HTTP/2 structures (i.e. those defined
 // in net/http2/http2_structures.h).
 
 // TODO(jamessynge): Combine tests of DoDecode, MaybeDecode, SlowDecode and
 // Http2StructureDecoder test using gUnit's support for tests parameterized
 // by type.
 
 #include <stddef.h>
 #include <string>
 
-#include "base/bind.h"
-#include "base/bind_helpers.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/http2_constants.h"
 #include "net/http2/http2_structures_test_util.h"
 #include "net/http2/tools/http2_frame_builder.h"
 #include "net/http2/tools/random_decoder_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 74 matching lines @@
     // Drained the input buffer, but not yet done.
     EXPECT_TRUE(b->Empty());
     EXPECT_GT(S::EncodedSize(), decode_offset_);
 
     return DecodeStatus::kDecodeInProgress;
   }
 
   // Set the fields of |*p| to random values.
   void Randomize(S* p) { ::net::test::Randomize(p, RandomPtr()); }
 
-  AssertionResult ValidatorForDecodeLeadingStructure(const S* expected,
-                                                     const DecodeBuffer& db,
-                                                     DecodeStatus status) {
-    if (expected != nullptr && *expected != structure_) {
-      return AssertionFailure()
-             << "Expected structs to be equal\nExpected: " << *expected
-             << "\n  Actual: " << structure_;
-    }
-    return AssertionSuccess();
-  }
-
   // Fully decodes the Structure at the start of data, and confirms it matches
   // *expected (if provided).
   void DecodeLeadingStructure(const S* expected, StringPiece data) {
     ASSERT_LE(S::EncodedSize(), data.size());
     DecodeBuffer original(data);
 
     // The validator is called after each of the several times that the input
     // DecodeBuffer is decoded, each with a different segmentation of the input.
     // Validate that structure_ matches the expected value, if provided.
-    Validator validator =
-        base::Bind(&StructureDecoderTest::ValidatorForDecodeLeadingStructure,
-                   base::Unretained(this), expected);
+    Validator validator = [expected, this](
+        const DecodeBuffer& db, DecodeStatus status) -> AssertionResult {
+      if (expected != nullptr && *expected != structure_) {
+        return AssertionFailure()
+               << "Expected structs to be equal\nExpected: " << *expected
+               << "\n  Actual: " << structure_;
+      }
+      return AssertionSuccess();
+    };
 
     // First validate that decoding is done and that we've advanced the cursor
     // the expected amount.
-    Validator wrapped_validator =
-        ValidateDoneAndOffset(S::EncodedSize(), validator);
+    validator = ValidateDoneAndOffset(S::EncodedSize(), validator);
 
     // Decode several times, with several segmentations of the input buffer.
     fast_decode_count_ = 0;
     slow_decode_count_ = 0;
     EXPECT_TRUE(DecodeAndValidateSeveralWays(
-        &original, false /*return_non_zero_on_first*/, wrapped_validator));
+        &original, false /*return_non_zero_on_first*/, validator));
 
     if (!HasFailure()) {
       EXPECT_EQ(S::EncodedSize(), decode_offset_);
       EXPECT_EQ(S::EncodedSize(), original.Offset());
       EXPECT_LT(0u, fast_decode_count_);
       EXPECT_LT(0u, slow_decode_count_);
       if (expected != nullptr) {
         DVLOG(1) << "DecodeLeadingStructure expected: " << *expected;
         DVLOG(1) << "DecodeLeadingStructure   actual: " << structure_;
         EXPECT_EQ(*expected, structure_);
@@ skipping 376 matching lines @@
   }
 }
 
 TEST_F(AltSvcFieldsDecoderTest, DecodesRandomized) {
   TestDecodingRandomizedStructures(100);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net