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

net/http2/hpack/decoder/hpack_entry_decoder_test.cc

Index: net/http2/hpack/decoder/hpack_entry_decoder_test.cc
diff --git a/net/http2/hpack/decoder/hpack_entry_decoder_test.cc b/net/http2/hpack/decoder/hpack_entry_decoder_test.cc
index 34581fad58474aab8b39dce0227177191952c436..6a1c293f2f047ef3c75ee96107dc68fb96e90e30 100644
--- a/net/http2/hpack/decoder/hpack_entry_decoder_test.cc
+++ b/net/http2/hpack/decoder/hpack_entry_decoder_test.cc
@@ -6,8 +6,6 @@
 
 // Tests of HpackEntryDecoder.
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "net/http2/hpack/decoder/hpack_entry_collector.h"
 #include "net/http2/hpack/tools/hpack_block_builder.h"
 #include "net/http2/tools/failure.h"
@@ -23,25 +21,6 @@ namespace test {
 namespace {
 
 class HpackEntryDecoderTest : public RandomDecoderTest {
- public:
-  AssertionResult ValidateIndexedHeader(uint32_t ndx) {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateIndexedHeader(ndx));
-  }
-
-  AssertionResult ValidateForIndexedLiteralValue_Literal() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralValueHeader(
-        HpackEntryType::kIndexedLiteralHeader, 0x40, false, "custom-header"));
-  }
-
-  AssertionResult ValidateForIndexedLiteralNameValue_Literal() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralNameValueHeader(
-        HpackEntryType::kIndexedLiteralHeader, false, "custom-key", false,
-        "custom-header"));
-  }
-
-  AssertionResult ValidateForDynamicTableSizeUpdate_Literal() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateDynamicTableSizeUpdate(31));
-  }
 
  protected:
   HpackEntryDecoderTest() : listener_(&collector_) {}
@@ -79,34 +58,34 @@ TEST_F(HpackEntryDecoderTest, IndexedHeader_Literals) {
   {
     const char input[] = {0x82u};  // == Index 2 ==
     DecodeBuffer b(input);
-    NoArgValidator do_check =
-        base::Bind(&HpackEntryDecoderTest::ValidateIndexedHeader,
-                   base::Unretained(this), 2);
+    NoArgValidator do_check = [this]() {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateIndexedHeader(2));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
   collector_.Clear();
   {
     const char input[] = {0xfeu};  // == Index 126 ==
     DecodeBuffer b(input);
-    NoArgValidator do_check =
-        base::Bind(&HpackEntryDecoderTest::ValidateIndexedHeader,
-                   base::Unretained(this), 126);
+    NoArgValidator do_check = [this]() {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateIndexedHeader(126));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
   collector_.Clear();
   {
     const char input[] = {0xffu, 0x00};  // == Index 127 ==
     DecodeBuffer b(input);
-    NoArgValidator do_check =
-        base::Bind(&HpackEntryDecoderTest::ValidateIndexedHeader,
-                   base::Unretained(this), 127);
+    NoArgValidator do_check = [this]() {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateIndexedHeader(127));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
 }
 
@@ -116,12 +95,12 @@ TEST_F(HpackEntryDecoderTest, IndexedHeader_Various) {
     HpackBlockBuilder hbb;
     hbb.AppendIndexedHeader(ndx);
 
-    NoArgValidator do_check =
-        base::Bind(&HpackEntryDecoderTest::ValidateIndexedHeader,
-                   base::Unretained(this), ndx);
+    NoArgValidator do_check = [this, ndx]() {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateIndexedHeader(ndx));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(hbb, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
 }
 
@@ -132,11 +111,12 @@ TEST_F(HpackEntryDecoderTest, IndexedLiteralValue_Literal) {
       "\x0d"            // Value length (13)
       "custom-header";  // Value
   DecodeBuffer b(input, sizeof input - 1);
-  NoArgValidator do_check =
-      base::Bind(&HpackEntryDecoderTest::ValidateForIndexedLiteralValue_Literal,
-                 base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralValueHeader(
+        HpackEntryType::kIndexedLiteralHeader, 0x40, false, "custom-header"));
+  };
   EXPECT_TRUE(DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 TEST_F(HpackEntryDecoderTest, IndexedLiteralNameValue_Literal) {
@@ -148,45 +128,29 @@ TEST_F(HpackEntryDecoderTest, IndexedLiteralNameValue_Literal) {
       "custom-header";  // Value
 
   DecodeBuffer b(input, sizeof input - 1);
-  NoArgValidator do_check = base::Bind(
-      &HpackEntryDecoderTest::ValidateForIndexedLiteralNameValue_Literal,
-      base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralNameValueHeader(
+        HpackEntryType::kIndexedLiteralHeader, false, "custom-key", false,
+        "custom-header"));
+  };
   EXPECT_TRUE(DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 TEST_F(HpackEntryDecoderTest, DynamicTableSizeUpdate_Literal) {
   // Size update, length 31.
   const char input[] = "\x3f\x00";
   DecodeBuffer b(input, 2);
-  NoArgValidator do_check = base::Bind(
-      &HpackEntryDecoderTest::ValidateForDynamicTableSizeUpdate_Literal,
-      base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateDynamicTableSizeUpdate(31));
+  };
   EXPECT_TRUE(DecodeAndValidateSeveralWays(&b, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 class HpackLiteralEntryDecoderTest
     : public HpackEntryDecoderTest,
       public ::testing::WithParamInterface<HpackEntryType> {
- public:
-  AssertionResult ValidateForRandNameIndexAndLiteralValue(
-      uint32_t ndx,
-      bool value_is_huffman_encoded,
-      const string& value) {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralValueHeader(
-        entry_type_, ndx, value_is_huffman_encoded, value));
-  }
-
-  AssertionResult ValidateForRandLiteralNameAndValue(
-      bool name_is_huffman_encoded,
-      const string& name,
-      bool value_is_huffman_encoded,
-      const string& value) {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralNameValueHeader(
-        entry_type_, name_is_huffman_encoded, name, value_is_huffman_encoded,
-        value));
-  }
 
  protected:
   HpackLiteralEntryDecoderTest() : entry_type_(GetParam()) {}
@@ -209,12 +173,14 @@ TEST_P(HpackLiteralEntryDecoderTest, RandNameIndexAndLiteralValue) {
     HpackBlockBuilder hbb;
     hbb.AppendNameIndexAndLiteralValue(entry_type_, ndx,
                                        value_is_huffman_encoded, value);
-    NoArgValidator do_check = base::Bind(
-        &HpackLiteralEntryDecoderTest::ValidateForRandNameIndexAndLiteralValue,
-        base::Unretained(this), ndx, value_is_huffman_encoded, value);
+    NoArgValidator do_check = [this, ndx, value_is_huffman_encoded,
+                               value]() -> AssertionResult {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralValueHeader(
+          entry_type_, ndx, value_is_huffman_encoded, value));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(hbb, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
 }
 
@@ -229,13 +195,16 @@ TEST_P(HpackLiteralEntryDecoderTest, RandLiteralNameAndValue) {
     HpackBlockBuilder hbb;
     hbb.AppendLiteralNameAndValue(entry_type_, name_is_huffman_encoded, name,
                                   value_is_huffman_encoded, value);
-    NoArgValidator do_check = base::Bind(
-        &HpackLiteralEntryDecoderTest::ValidateForRandLiteralNameAndValue,
-        base::Unretained(this), name_is_huffman_encoded, name,
-        value_is_huffman_encoded, value);
+    NoArgValidator do_check = [this, name_is_huffman_encoded, name,
+                               value_is_huffman_encoded,
+                               value]() -> AssertionResult {
+      VERIFY_AND_RETURN_SUCCESS(collector_.ValidateLiteralNameValueHeader(
+          entry_type_, name_is_huffman_encoded, name, value_is_huffman_encoded,
+          value));
+    };
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(hbb, ValidateDoneAndEmpty(do_check)));
-    EXPECT_TRUE(do_check.Run());
+    EXPECT_TRUE(do_check());
   }
 }