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

net/http2/decoder/http2_structure_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_structure_decoder.h"
 
 // Tests decoding all of the fixed size HTTP/2 structures (i.e. those defined in
 // net/http2/http2_structures.h) using Http2StructureDecoder, which handles
 // buffering of structures split across input buffer boundaries, and in turn
 // uses DoDecode when it has all of a structure in a contiguous buffer.
 
 // NOTE: This tests the first pair of Start and Resume, which don't take
 // a remaining_payload parameter. The other pair are well tested via the
 // payload decoder tests, though...
 // TODO(jamessynge): Create type parameterized tests for Http2StructureDecoder
 // where the type is the type of structure, and with testing of both pairs of
 // Start and Resume methods; note that it appears that the first pair will be
 // used only for Http2FrameHeader, and the other pair only for structures in the
 // frame payload.
 
 #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/failure.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 59 matching lines @@
       return DecodeStatus::kDecodeDone;
     } else {
       EXPECT_LT(structure_decoder_.offset(), S::EncodedSize());
       EXPECT_EQ(0u, b->Remaining());
       EXPECT_GT(S::EncodedSize(), old_offset + avail);
       ++incomplete_resume_count_;
       return DecodeStatus::kDecodeInProgress;
     }
   }
 
-  AssertionResult ValidatorForDecodeLeadingStructure(const S* expected,
-                                                     const DecodeBuffer& db,
-                                                     DecodeStatus status) {
-    VERIFY_EQ(*expected, structure_);
-    return AssertionSuccess();
-  }
 
   // Fully decodes the Structure at the start of data, and confirms it matches
   // *expected (if provided).
   AssertionResult DecodeLeadingStructure(const S* expected, StringPiece data) {
     VERIFY_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 =
-        (expected == nullptr)
-            ? base::Bind(&SucceedingValidator)
-            : base::Bind(&Http2StructureDecoderTest::
-                             ValidatorForDecodeLeadingStructure,
-                         base::Unretained(this), expected);
+    Validator validator;
+    if (expected != nullptr) {
+      validator = [expected, this](const DecodeBuffer& db,
+                                   DecodeStatus status) -> AssertionResult {
+        VERIFY_EQ(*expected, structure_);
+        return AssertionSuccess();
+      };
+    }
 
     // Before that, 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;
     incomplete_start_count_ = 0;
     incomplete_resume_count_ = 0;
     VERIFY_SUCCESS(DecodeAndValidateSeveralWays(
-        &original, kMayReturnZeroOnFirst, wrapped_validator));
+        &original, kMayReturnZeroOnFirst, validator));
     VERIFY_FALSE(HasFailure());
     VERIFY_EQ(S::EncodedSize(), structure_decoder_.offset());
     VERIFY_EQ(S::EncodedSize(), original.Offset());
     VERIFY_LT(0u, fast_decode_count_);
     VERIFY_LT(0u, slow_decode_count_);
     VERIFY_LT(0u, incomplete_start_count_);
 
     // If the structure is large enough so that SelectZeroOrOne will have
     // caused Resume to return false, check that occurred.
     if (S::EncodedSize() >= 2) {
@@ skipping 353 matching lines @@
   }
 }
 
 TEST_F(Http2AltSvcFieldsDecoderTest, DecodesRandomized) {
   TestDecodingRandomizedStructures();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net