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

net/http2/tools/random_decoder_test.h

 // Copyright 2016 The Chromium Authors. All rights reserved.

[James Synge, 2017/01/05 21:39:06]

There are a bunch of minor comment differences in this file vs. the original,
but it isn't clear why that should be.

[Bence, 2017/01/06 01:42:40]

I am not sure which revision I was using when preparing this change.  I will
definitely revisit differences once Chromium code is brought up-to-date with
internal code.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
 #define NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_
 
 // RandomDecoderTest is a base class for tests of decoding various kinds
 // of HTTP/2 and HPACK encodings.
 
 // TODO(jamessynge): Move more methods into .cc file.
 
 #include <stddef.h>
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <type_traits>
 
-#include "base/bind.h"
-#include "base/callback.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/template_util.h"
 #include "net/http2/decoder/decode_buffer.h"
 #include "net/http2/decoder/decode_status.h"
 #include "net/http2/tools/failure.h"
 #include "net/http2/tools/http2_random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 33 matching lines @@
   // SelectSize returns the size of the next DecodeBuffer to be passed to the
   // decoder. Note that RandomDecoderTest allows that size to be zero, though
   // some decoders can't deal with that on the first byte, hence the |first|
   // parameter.
   typedef std::function<size_t(bool first, size_t offset, size_t remaining)>
       SelectSize;
 
   // Validator returns an AssertionResult so test can do:
   // EXPECT_THAT(DecodeAndValidate(..., validator));
   typedef ::testing::AssertionResult AssertionResult;
-  typedef base::Callback<AssertionResult(const DecodeBuffer& input,
-                                         DecodeStatus status)>
+  typedef std::function<AssertionResult(const DecodeBuffer& input,
+                                        DecodeStatus status)>
       Validator;
-  typedef base::Callback<AssertionResult()> NoArgValidator;
+  typedef std::function<AssertionResult()> NoArgValidator;
 
   RandomDecoderTest();
 
  protected:
   // TODO(jamessynge): Modify StartDecoding, etc. to (somehow) return
   // AssertionResult so that the VERIFY_* methods exported from
   // gunit_helpers.h can be widely used.
 
   // Start decoding; call allows sub-class to Reset the decoder, or deal with
   // the first byte if that is done in a unique fashion.  Might be called with
@@ skipping 25 matching lines @@
   // We do this to test the ability to deal with arbitrary boundaries, as might
   // happen in transport.
   // Invokes |validator| with the final decode status and the original decode
   // buffer, with the cursor advanced as far as has been consumed by the decoder
   // and returns validator's result.
   ::testing::AssertionResult DecodeSegmentsAndValidate(
       DecodeBuffer* original,
       const SelectSize& select_size,
       const Validator& validator) {
     DecodeStatus status = DecodeSegments(original, select_size);
-    VERIFY_AND_RETURN_SUCCESS(validator.Run(*original, status));
+    VERIFY_AND_RETURN_SUCCESS(validator(*original, status));
   }
 
   // Returns a SelectSize function for fast decoding, i.e. passing all that
   // is available to the decoder.
   static SelectSize SelectRemaining() {
     return [](bool first, size_t offset, size_t remaining) -> size_t {
       return remaining;
     };
   }
 
@@ skipping 11 matching lines @@
   SelectSize SelectRandom(bool return_non_zero_on_first);
 
   // Decode |original| multiple times, with different segmentations of the
   // decode buffer, validating after each decode, and confirming that they
   // each decode the same amount. Returns on the first failure, else returns
   // success.
   AssertionResult DecodeAndValidateSeveralWays(DecodeBuffer* original,
                                                bool return_non_zero_on_first,
                                                const Validator& validator);
 
-  static AssertionResult SucceedingValidator(const DecodeBuffer& input,
-                                             DecodeStatus status) {
-    return ::testing::AssertionSuccess();
+  static Validator ToValidator(std::nullptr_t) {
+    return [](const DecodeBuffer& input, DecodeStatus status) {
+      return ::testing::AssertionSuccess();
+    };
   }
 
-  static Validator ToValidator(const Validator& validator) { return validator; }
-
-  static AssertionResult RunNoArgValidator(const NoArgValidator& validator,
-                                           const DecodeBuffer& input,
-                                           DecodeStatus status) {
-    return validator.Run();
+  static Validator ToValidator(const Validator& validator) {
+    if (validator == nullptr) {
+      return ToValidator(nullptr);
+    }
+    return validator;
   }
 
   static Validator ToValidator(const NoArgValidator& validator) {
-    return base::Bind(&RunNoArgValidator, validator);
+    if (validator == nullptr) {
+      return ToValidator(nullptr);
+    }
+    return [validator](const DecodeBuffer& input, DecodeStatus status) {
+      return validator();
+    };
   }
 
   // Wraps a validator with another validator
   // that first checks that the DecodeStatus is kDecodeDone and
   // that the DecodeBuffer is empty.
   // TODO(jamessynge): Replace this overload with the next, as using this method
   // usually means that the wrapped function doesn't need to be passed the
   // DecodeBuffer nor the DecodeStatus.
-  static AssertionResult ValidateDoneAndEmptyImpl(const Validator& wrapped,
-                                                  const DecodeBuffer& input,
-                                                  DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-    VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
-    return wrapped.Run(input, status);
+  static Validator ValidateDoneAndEmpty(const Validator& wrapped) {
+    return [wrapped](const DecodeBuffer& input,
+                     DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+      if (wrapped) {
+        return wrapped(input, status);
+      }
+      return ::testing::AssertionSuccess();
+    };
   }
-  static Validator ValidateDoneAndEmpty(const Validator& wrapped) {
-    return base::Bind(&ValidateDoneAndEmptyImpl, wrapped);
-  }
-  static AssertionResult ValidateDoneAndEmptyNoArgImpl(
-      const NoArgValidator& wrapped,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-    VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
-    return wrapped.Run();
-  }
-  static Validator ValidateDoneAndEmpty(const NoArgValidator& wrapped) {
-    return base::Bind(&ValidateDoneAndEmptyNoArgImpl, wrapped);
+  static Validator ValidateDoneAndEmpty(NoArgValidator wrapped) {
+    return [wrapped](const DecodeBuffer& input,
+                     DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      VERIFY_EQ(0u, input.Remaining()) << "\nOffset=" << input.Offset();
+      if (wrapped) {
+        return wrapped();
+      }
+      return ::testing::AssertionSuccess();
+    };
   }
   static Validator ValidateDoneAndEmpty() {
-    return ValidateDoneAndEmpty(base::Bind(&SucceedingValidator));
+    NoArgValidator validator;
+    return ValidateDoneAndEmpty(validator);
   }
 
   // Wraps a validator with another validator
   // that first checks that the DecodeStatus is kDecodeDone and
   // that the DecodeBuffer has the expected offset.
   // TODO(jamessynge): Replace this overload with the next, as using this method
   // usually means that the wrapped function doesn't need to be passed the
   // DecodeBuffer nor the DecodeStatus.
-  static AssertionResult ValidateDoneAndOffsetImpl(uint32_t offset,
-                                                   const Validator& wrapped,
-                                                   const DecodeBuffer& input,
-                                                   DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-    VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
-    return wrapped.Run(input, status);
+  static Validator ValidateDoneAndOffset(uint32_t offset, Validator wrapped) {
+    return [wrapped, offset](const DecodeBuffer& input,
+                             DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+      if (wrapped) {
+        return wrapped(input, status);
+      }
+      return ::testing::AssertionSuccess();
+    };
   }
   static Validator ValidateDoneAndOffset(uint32_t offset,
-                                         const Validator& wrapped) {
-    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
-    // issues if this method is called with a temporary Validator.
-    return base::Bind(&ValidateDoneAndOffsetImpl, offset, wrapped);
-  }
-  static AssertionResult ValidateDoneAndOffsetNoArgImpl(
-      uint32_t offset,
-      const NoArgValidator& wrapped,
-      const DecodeBuffer& input,
-      DecodeStatus status) {
-    VERIFY_EQ(status, DecodeStatus::kDecodeDone);
-    VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
-    return wrapped.Run();
-  }
-  static Validator ValidateDoneAndOffset(uint32_t offset,
-                                         const NoArgValidator& wrapped) {
-    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
-    // issues if this method is called with a temporary Validator.
-    return base::Bind(&ValidateDoneAndOffsetNoArgImpl, offset, wrapped);
+                                         NoArgValidator wrapped) {
+    return [wrapped, offset](const DecodeBuffer& input,
+                             DecodeStatus status) -> AssertionResult {
+      VERIFY_EQ(status, DecodeStatus::kDecodeDone);
+      VERIFY_EQ(offset, input.Offset()) << "\nRemaining=" << input.Remaining();
+      if (wrapped) {
+        return wrapped();
+      }
+      return ::testing::AssertionSuccess();
+    };
   }
   static Validator ValidateDoneAndOffset(uint32_t offset) {
-    // Make a copy of |wrapped| (by not using base::ConstRef) to avoid lifetime
-    // issues if this method is called with a temporary Validator.
-    return ValidateDoneAndOffset(offset, base::Bind(&SucceedingValidator));
+    NoArgValidator validator;
+    return ValidateDoneAndOffset(offset, validator);
   }
 
   // Expose |random_| as RandomBase so callers do not have to care about which
   // sub-class of RandomBase is used, nor can they rely on the specific
   // sub-class that RandomDecoderTest uses.
   RandomBase& Random() { return random_; }
   RandomBase* RandomPtr() { return &random_; }
 
   uint32_t RandStreamId();
 
   bool stop_decode_on_done_ = true;
 
  private:
   Http2Random random_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_HTTP2_TOOLS_RANDOM_DECODER_TEST_H_