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

net/http2/hpack/decoder/hpack_varint_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/hpack/decoder/hpack_varint_decoder.h"
 
 // Tests of HpackVarintDecoder.
 
 #include <stddef.h>
 
 #include <ios>
 #include <iterator>
 #include <ostream>
 #include <set>
 #include <sstream>
 #include <vector>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "net/http2/hpack/tools/hpack_block_builder.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 ::testing::AssertionFailure;
 using ::testing::AssertionSuccess;
 using base::StringPiece;
 using base::StringPrintf;
 using std::string;
 
 namespace net {
 namespace test {
 namespace {
 
 class HpackVarintDecoderTest : public RandomDecoderTest {
- public:
-  AssertionResult ValidatorForValueTooLarge(bool* validated,
-                                            uint32_t expected_offset,
-                                            const DecodeBuffer& db,
-                                            DecodeStatus status) {
-    *validated = true;
-    VERIFY_EQ(DecodeStatus::kDecodeError, status);
-    VERIFY_EQ(expected_offset, db.Offset());
-    return AssertionSuccess();
-  }
 
  protected:
   DecodeStatus StartDecoding(DecodeBuffer* b) override {
     CHECK_LT(0u, b->Remaining());
     CHECK_NE(0, prefix_mask_);
     uint8_t prefix = b->DecodeUInt8();
     return decoder_.Start(prefix, prefix_mask_, b);
   }
 
   DecodeStatus ResumeDecoding(DecodeBuffer* b) override {
     return decoder_.Resume(b);
   }
 
-  AssertionResult ValidatorForDecodeSeveralWays(uint32_t expected_value,
-                                                const DecodeBuffer& db,
-                                                DecodeStatus status) {
-    if (decoder_.value() != expected_value) {
-      return AssertionFailure()
-             << "Value doesn't match expected: " << decoder_.value()
-             << " != " << expected_value;
-    }
-    return AssertionSuccess();
-  }
-
   void DecodeSeveralWays(uint32_t expected_value, uint32_t expected_offset) {
     // 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 decoder_.value() matches the expected value.
-    Validator validator =
-        base::Bind(&HpackVarintDecoderTest::ValidatorForDecodeSeveralWays,
-                   base::Unretained(this), expected_value);
+    Validator validator = [expected_value, this](
+        const DecodeBuffer& db, DecodeStatus status) -> AssertionResult {
+      if (decoder_.value() != expected_value) {
+        return AssertionFailure()
+               << "Value doesn't match expected: " << decoder_.value()
+               << " != " << expected_value;
+      }
+      return AssertionSuccess();
+    };
 
     // First validate that decoding is done and that we've advanced the cursor
     // the expected amount.
     validator = ValidateDoneAndOffset(expected_offset, validator);
 
     // StartDecoding, above, requires the DecodeBuffer be non-empty so that it
     // can call Start with the prefix byte.
     bool return_non_zero_on_first = true;
 
     DecodeBuffer b(buffer_);
@@ skipping 276 matching lines @@
     uint64_t too_large = HpackVarintDecoder::HiValueOfExtensionBytes(
         HpackVarintDecoder::MaxExtensionBytes() + 3, prefix_length_);
     HpackBlockBuilder bb;
     bb.AppendHighBitsAndVarint(0, prefix_length_, too_large);
     buffer_ = bb.buffer();
 
     // 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 decoder_.value() matches the expected value.
     bool validated = false;
-    Validator validator =
-        base::Bind(&HpackVarintDecoderTest::ValidatorForValueTooLarge,
-                   base::Unretained(this), &validated, expected_offset);
+    Validator validator = [&validated, expected_offset](
+        const DecodeBuffer& db, DecodeStatus status) -> AssertionResult {
+      validated = true;
+      VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      VERIFY_EQ(expected_offset, db.Offset());
+      return AssertionSuccess();
+    };
 
     // StartDecoding, above, requires the DecodeBuffer be non-empty so that it
     // can call Start with the prefix byte.
     bool return_non_zero_on_first = true;
     DecodeBuffer b(buffer_);
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(&b, return_non_zero_on_first, validator));
     EXPECT_EQ(expected_offset, b.Offset());
     EXPECT_TRUE(validated);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net