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

net/http2/hpack/decoder/hpack_string_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_string_decoder.h"
 
 // Tests of HpackStringDecoder.
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/strings/string_piece.h"
 #include "net/http2/hpack/decoder/hpack_string_collector.h"
 #include "net/http2/hpack/decoder/hpack_string_decoder_listener.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::AssertionResult;
@@ skipping 46 matching lines @@
     VLOG(1) << decoder_.DebugString();
     VLOG(2) << collector_;
     return decoder_.Resume(b, &listener_);
   }
 
   AssertionResult Collected(StringPiece s, bool huffman_encoded) {
     VLOG(1) << collector_;
     return collector_.Collected(s, huffman_encoded);
   }
 
-  // Note that base::Bind() makes a copy of |expected_str| even though it is
-  // taken as a constant reference, so even if MakeValidator is called with a
-  // C-style string that is cast to a temporary std::string that gets destroyed
-  // after the call to MakeValidator, |expected_str| is still valid later when
-  // the Validator is run.
-  AssertionResult StringValidator(const string& expected_str,
-                                  bool expected_huffman,
-                                  const DecodeBuffer& input,
-                                  DecodeStatus status) {
-    AssertionResult result = Collected(expected_str, expected_huffman);
-    if (result) {
-      VERIFY_EQ(collector_,
-                HpackStringCollector(expected_str, expected_huffman));
-    } else {
-      VERIFY_NE(collector_,
-                HpackStringCollector(expected_str, expected_huffman));
-    }
-    VLOG(2) << collector_.ToString();
-    collector_.Clear();
-    VLOG(2) << collector_;
-    return result;
-  }
+  // expected_str is a string rather than a const string& or StringPiece so that
+  // the lambda makes a copy of the string, and thus the string to be passed to
+  // Collected outlives the call to MakeValidator.
 
   Validator MakeValidator(const string& expected_str, bool expected_huffman) {
-    return base::Bind(&HpackStringDecoderTest::StringValidator,
-                      base::Unretained(this), expected_str, expected_huffman);
+    return
+        [expected_str, expected_huffman, this](
+            const DecodeBuffer& input, DecodeStatus status) -> AssertionResult {
+          AssertionResult result = Collected(expected_str, expected_huffman);
+          if (result) {
+            VERIFY_EQ(collector_,
+                      HpackStringCollector(expected_str, expected_huffman));
+          } else {
+            VERIFY_NE(collector_,
+                      HpackStringCollector(expected_str, expected_huffman));
+          }
+          VLOG(2) << collector_.ToString();
+          collector_.Clear();
+          VLOG(2) << collector_;
+          return result;
+        };
   }
 
   const StartMethod start_method_;
   HpackStringDecoder decoder_;
   HpackStringCollector collector_;
   HpackStringDecoderVLoggingListener listener_;
   size_t start_decoding_calls_ = 0;
 };
 
 TEST_P(HpackStringDecoderTest, DecodeEmptyString) {
@@ skipping 72 matching lines @@
 INSTANTIATE_TEST_CASE_P(AllStartMethods,
                         HpackStringDecoderTest,
                         ::testing::Values(kStart,
                                           kStartOnly,
                                           kStartAndDecodeLength,
                                           kStartSpecialCaseShort));
 
 }  // namespace
 }  // namespace test
 }  // namespace net