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

net/http2/hpack/decoder/hpack_block_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_block_decoder.h"
 
 // Tests of HpackBlockDecoder.
 
 #include <sstream>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "net/http2/decoder/decode_buffer.h"
 #include "net/http2/hpack/decoder/hpack_block_collector.h"
 #include "net/http2/hpack/http2_hpack_constants.h"
 #include "net/http2/hpack/tools/hpack_block_builder.h"
 #include "net/http2/hpack/tools/hpack_example.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::AssertionSuccess;
 using std::string;
 using base::StringPiece;
 
 namespace net {
 namespace test {
 namespace {
 
 class HpackBlockDecoderTest : public RandomDecoderTest {
- public:
-  AssertionResult VerifyExpected(const HpackBlockCollector& expected) {
-    VERIFY_AND_RETURN_SUCCESS(collector_.VerifyEq(expected));
-  }
-
-  AssertionResult ValidateForSpecExample_C_2_1() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralNameValueHeader(
-        HpackEntryType::kIndexedLiteralHeader, false, "custom-key", false,
-        "custom-header"));
-  }
-
-  AssertionResult ValidateForSpecExample_C_2_2() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralValueHeader(
-        HpackEntryType::kUnindexedLiteralHeader, 4, false, "/sample/path"));
-  }
-
-  AssertionResult ValidateForSpecExample_C_2_3() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralNameValueHeader(
-        HpackEntryType::kNeverIndexedLiteralHeader, false, "password", false,
-        "secret"));
-  }
-
-  AssertionResult ValidateForSpecExample_C_2_4() {
-    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleIndexedHeader(2));
-  }
 
  protected:
   HpackBlockDecoderTest() : listener_(&collector_), decoder_(&listener_) {
     stop_decode_on_done_ = false;
     decoder_.Reset();
     // Make sure logging doesn't crash. Not examining the result.
     std::ostringstream strm;
     strm << decoder_;
   }
 
@@ skipping 38 matching lines @@
 
   string Rand8String() { return Random().RandString(Rand8()); }
 
   HpackBlockCollector collector_;
   HpackEntryDecoderVLoggingListener listener_;
   HpackBlockDecoder decoder_;
 };
 
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.2.1
 TEST_F(HpackBlockDecoderTest, SpecExample_C_2_1) {
-  NoArgValidator do_check =
-      base::Bind(&HpackBlockDecoderTest::ValidateForSpecExample_C_2_1,
-                 base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralNameValueHeader(
+        HpackEntryType::kIndexedLiteralHeader, false, "custom-key", false,
+        "custom-header"));
+  };
   EXPECT_TRUE(
       DecodeHpackExampleAndValidateSeveralWays(R"(
       40                                      | == Literal indexed ==
       0a                                      |   Literal name (len = 10)
       6375 7374 6f6d 2d6b 6579                | custom-key
       0d                                      |   Literal value (len = 13)
       6375 7374 6f6d 2d68 6561 6465 72        | custom-header
                                               | -> custom-key:
                                               |   custom-header
       )",
                                                ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.2.2
 TEST_F(HpackBlockDecoderTest, SpecExample_C_2_2) {
-  NoArgValidator do_check =
-      base::Bind(&HpackBlockDecoderTest::ValidateForSpecExample_C_2_2,
-                 base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralValueHeader(
+        HpackEntryType::kUnindexedLiteralHeader, 4, false, "/sample/path"));
+  };
   EXPECT_TRUE(
       DecodeHpackExampleAndValidateSeveralWays(R"(
       04                                      | == Literal not indexed ==
                                               |   Indexed name (idx = 4)
                                               |     :path
       0c                                      |   Literal value (len = 12)
       2f73 616d 706c 652f 7061 7468           | /sample/path
                                               | -> :path: /sample/path
       )",
                                                ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.2.3
 TEST_F(HpackBlockDecoderTest, SpecExample_C_2_3) {
-  NoArgValidator do_check =
-      base::Bind(&HpackBlockDecoderTest::ValidateForSpecExample_C_2_3,
-                 base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleLiteralNameValueHeader(
+        HpackEntryType::kNeverIndexedLiteralHeader, false, "password", false,
+        "secret"));
+  };
   EXPECT_TRUE(
       DecodeHpackExampleAndValidateSeveralWays(R"(
       10                                      | == Literal never indexed ==
       08                                      |   Literal name (len = 8)
       7061 7373 776f 7264                     | password
       06                                      |   Literal value (len = 6)
       7365 6372 6574                          | secret
                                               | -> password: secret
       )",
                                                ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.2.4
 TEST_F(HpackBlockDecoderTest, SpecExample_C_2_4) {
-  NoArgValidator do_check =
-      base::Bind(&HpackBlockDecoderTest::ValidateForSpecExample_C_2_4,
-                 base::Unretained(this));
+  NoArgValidator do_check = [this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.ValidateSoleIndexedHeader(2));
+  };
   EXPECT_TRUE(
       DecodeHpackExampleAndValidateSeveralWays(R"(
       82                                      | == Indexed - Add ==
                                               |   idx = 2
                                               | -> :method: GET
       )",
                                                ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.3.1
 TEST_F(HpackBlockDecoderTest, SpecExample_C_3_1) {
   string example = R"(
       82                                      | == Indexed - Add ==
                                               |   idx = 2
                                               | -> :method: GET
       86                                      | == Indexed - Add ==
                                               |   idx = 6
                                               | -> :scheme: http
       84                                      | == Indexed - Add ==
                                               |   idx = 4
                                               | -> :path: /
       41                                      | == Literal indexed ==
                                               |   Indexed name (idx = 1)
                                               |     :authority
       0f                                      |   Literal value (len = 15)
       7777 772e 6578 616d 706c 652e 636f 6d   | www.example.com
                                               | -> :authority:
                                               |   www.example.com
       )";
   HpackBlockCollector expected;
   expected.ExpectIndexedHeader(2);
   expected.ExpectIndexedHeader(6);
   expected.ExpectIndexedHeader(4);
   expected.ExpectNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader,
                                           1, false, "www.example.com");
-  NoArgValidator do_check = base::Bind(&HpackBlockDecoderTest::VerifyExpected,
-                                       base::Unretained(this), expected);
+  NoArgValidator do_check = [expected, this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.VerifyEq(expected));
+  };
   EXPECT_TRUE(DecodeHpackExampleAndValidateSeveralWays(
       example, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 // http://httpwg.org/specs/rfc7541.html#rfc.section.C.5.1
 TEST_F(HpackBlockDecoderTest, SpecExample_C_5_1) {
   string example = R"(
       48                                      | == Literal indexed ==
                                               |   Indexed name (idx = 8)
                                               |     :status
       03                                      |   Literal value (len = 3)
       3330 32                                 | 302
@@ skipping 24 matching lines @@
   HpackBlockCollector expected;
   expected.ExpectNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader,
                                           8, false, "302");
   expected.ExpectNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader,
                                           24, false, "private");
   expected.ExpectNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader,
                                           33, false,
                                           "Mon, 21 Oct 2013 20:13:21 GMT");
   expected.ExpectNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader,
                                           46, false, "https://www.example.com");
-  NoArgValidator do_check = base::Bind(&HpackBlockDecoderTest::VerifyExpected,
-                                       base::Unretained(this), expected);
+  NoArgValidator do_check = [expected, this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.VerifyEq(expected));
+  };
   EXPECT_TRUE(DecodeHpackExampleAndValidateSeveralWays(
       example, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 // Generate a bunch of HPACK block entries to expect, use those expectations
 // to generate an HPACK block, then decode it and confirm it matches those
 // expectations. Some of these are invalid (such as Indexed, with index=0),
 // but well-formed, and the decoder doesn't check for validity, just
 // well-formedness. That includes the validity of the strings not being checked,
 // such as lower-case ascii for the names, and valid Huffman encodings.
 TEST_F(HpackBlockDecoderTest, Computed) {
   HpackBlockCollector expected;
@@ skipping 24 matching lines @@
                                          value_huffman, Rand8String());
       expected.ExpectLiteralNameAndValue(type, true, Rand8String(),
                                          value_huffman, Rand8String());
     }
   }
   // Shuffle the entries and serialize them to produce an HPACK block.
   expected.ShuffleEntries(RandomPtr());
   HpackBlockBuilder hbb;
   expected.AppendToHpackBlockBuilder(&hbb);
 
-  NoArgValidator do_check = base::Bind(&HpackBlockDecoderTest::VerifyExpected,
-                                       base::Unretained(this), expected);
+  NoArgValidator do_check = [expected, this]() {
+    VERIFY_AND_RETURN_SUCCESS(collector_.VerifyEq(expected));
+  };
   EXPECT_TRUE(
       DecodeAndValidateSeveralWays(hbb, ValidateDoneAndEmpty(do_check)));
-  EXPECT_TRUE(do_check.Run());
+  EXPECT_TRUE(do_check());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net