123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785 |
- // Copyright (c) 2012 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 "base/callback.h"
- #include <memory>
- #include <utility>
- #include "base/bind.h"
- #include "base/callback_internal.h"
- #include "base/memory/raw_ptr.h"
- #include "base/memory/ref_counted.h"
- #include "base/notreached.h"
- #include "base/strings/string_number_conversions.h"
- #include "base/test/bind.h"
- #include "base/test/test_timeouts.h"
- #include "base/threading/thread.h"
- #include "testing/gtest/include/gtest/gtest.h"
- namespace base {
- void NopInvokeFunc() {}
- // White-box testpoints to inject into a callback object for checking
- // comparators and emptiness APIs. Use a BindState that is specialized based on
- // a type we declared in the anonymous namespace above to remove any chance of
- // colliding with another instantiation and breaking the one-definition-rule.
- struct FakeBindState : internal::BindStateBase {
- FakeBindState() : BindStateBase(&NopInvokeFunc, &Destroy, &IsCancelled) {}
- private:
- ~FakeBindState() = default;
- static void Destroy(const internal::BindStateBase* self) {
- delete static_cast<const FakeBindState*>(self);
- }
- static bool IsCancelled(const internal::BindStateBase*,
- internal::BindStateBase::CancellationQueryMode mode) {
- switch (mode) {
- case internal::BindStateBase::IS_CANCELLED:
- return false;
- case internal::BindStateBase::MAYBE_VALID:
- return true;
- }
- NOTREACHED();
- }
- };
- namespace {
- class CallbackTest : public ::testing::Test {
- public:
- CallbackTest()
- : callback_a_(new FakeBindState()), callback_b_(new FakeBindState()) {}
- ~CallbackTest() override = default;
- protected:
- RepeatingCallback<void()> callback_a_;
- const RepeatingCallback<void()> callback_b_; // Ensure APIs work with const.
- RepeatingCallback<void()> null_callback_;
- };
- TEST_F(CallbackTest, Types) {
- static_assert(std::is_same<void, OnceClosure::ResultType>::value, "");
- static_assert(std::is_same<void(), OnceClosure::RunType>::value, "");
- using OnceCallbackT = OnceCallback<double(int, char)>;
- static_assert(std::is_same<double, OnceCallbackT::ResultType>::value, "");
- static_assert(std::is_same<double(int, char), OnceCallbackT::RunType>::value,
- "");
- static_assert(std::is_same<void, RepeatingClosure::ResultType>::value, "");
- static_assert(std::is_same<void(), RepeatingClosure::RunType>::value, "");
- using RepeatingCallbackT = RepeatingCallback<bool(float, short)>;
- static_assert(std::is_same<bool, RepeatingCallbackT::ResultType>::value, "");
- static_assert(
- std::is_same<bool(float, short), RepeatingCallbackT::RunType>::value, "");
- }
- // Ensure we can create unbound callbacks. We need this to be able to store
- // them in class members that can be initialized later.
- TEST_F(CallbackTest, DefaultConstruction) {
- RepeatingCallback<void()> c0;
- RepeatingCallback<void(int)> c1;
- RepeatingCallback<void(int, int)> c2;
- RepeatingCallback<void(int, int, int)> c3;
- RepeatingCallback<void(int, int, int, int)> c4;
- RepeatingCallback<void(int, int, int, int, int)> c5;
- RepeatingCallback<void(int, int, int, int, int, int)> c6;
- EXPECT_TRUE(c0.is_null());
- EXPECT_TRUE(c1.is_null());
- EXPECT_TRUE(c2.is_null());
- EXPECT_TRUE(c3.is_null());
- EXPECT_TRUE(c4.is_null());
- EXPECT_TRUE(c5.is_null());
- EXPECT_TRUE(c6.is_null());
- }
- TEST_F(CallbackTest, IsNull) {
- EXPECT_TRUE(null_callback_.is_null());
- EXPECT_FALSE(callback_a_.is_null());
- EXPECT_FALSE(callback_b_.is_null());
- }
- TEST_F(CallbackTest, Equals) {
- EXPECT_EQ(callback_a_, callback_a_);
- EXPECT_NE(callback_a_, callback_b_);
- EXPECT_NE(callback_b_, callback_a_);
- // We should compare based on instance, not type.
- RepeatingCallback<void()> callback_c(new FakeBindState());
- RepeatingCallback<void()> callback_a2 = callback_a_;
- EXPECT_EQ(callback_a_, callback_a2);
- EXPECT_NE(callback_a_, callback_c);
- // Empty, however, is always equal to empty.
- RepeatingCallback<void()> empty2;
- EXPECT_EQ(null_callback_, empty2);
- }
- TEST_F(CallbackTest, Reset) {
- // Resetting should bring us back to empty.
- ASSERT_FALSE(callback_a_.is_null());
- EXPECT_NE(callback_a_, null_callback_);
- callback_a_.Reset();
- EXPECT_TRUE(callback_a_.is_null());
- EXPECT_EQ(callback_a_, null_callback_);
- }
- TEST_F(CallbackTest, Move) {
- // Moving should reset the callback.
- ASSERT_FALSE(callback_a_.is_null());
- EXPECT_NE(callback_a_, null_callback_);
- auto tmp = std::move(callback_a_);
- EXPECT_TRUE(callback_a_.is_null());
- EXPECT_EQ(callback_a_, null_callback_);
- }
- TEST_F(CallbackTest, NullAfterMoveRun) {
- RepeatingCallback<void(void*)> cb = BindRepeating([](void* param) {
- EXPECT_TRUE(static_cast<RepeatingCallback<void(void*)>*>(param)->is_null());
- });
- ASSERT_TRUE(cb);
- std::move(cb).Run(&cb);
- EXPECT_FALSE(cb);
- const RepeatingClosure cb2 = BindRepeating([] {});
- ASSERT_TRUE(cb2);
- std::move(cb2).Run();
- EXPECT_TRUE(cb2);
- OnceCallback<void(void*)> cb3 = BindOnce([](void* param) {
- EXPECT_TRUE(static_cast<OnceCallback<void(void*)>*>(param)->is_null());
- });
- ASSERT_TRUE(cb3);
- std::move(cb3).Run(&cb3);
- EXPECT_FALSE(cb3);
- }
- TEST_F(CallbackTest, MaybeValidReturnsTrue) {
- RepeatingCallback<void()> cb = BindRepeating([]() {});
- // By default, MaybeValid() just returns true all the time.
- EXPECT_TRUE(cb.MaybeValid());
- cb.Run();
- EXPECT_TRUE(cb.MaybeValid());
- }
- TEST_F(CallbackTest, ThenResetsOriginalCallback) {
- {
- // OnceCallback::Then() always destroys the original callback.
- OnceClosure orig = base::BindOnce([]() {});
- EXPECT_TRUE(!!orig);
- OnceClosure joined = std::move(orig).Then(base::BindOnce([]() {}));
- EXPECT_TRUE(!!joined);
- EXPECT_FALSE(!!orig);
- }
- {
- // RepeatingCallback::Then() destroys the original callback if it's an
- // rvalue.
- RepeatingClosure orig = base::BindRepeating([]() {});
- EXPECT_TRUE(!!orig);
- RepeatingClosure joined =
- std::move(orig).Then(base::BindRepeating([]() {}));
- EXPECT_TRUE(!!joined);
- EXPECT_FALSE(!!orig);
- }
- {
- // RepeatingCallback::Then() doesn't destroy the original callback if it's
- // not an rvalue.
- RepeatingClosure orig = base::BindRepeating([]() {});
- RepeatingClosure copy = orig;
- EXPECT_TRUE(!!orig);
- RepeatingClosure joined = orig.Then(base::BindRepeating([]() {}));
- EXPECT_TRUE(!!joined);
- EXPECT_TRUE(!!orig);
- // The original callback is not changed.
- EXPECT_EQ(orig, copy);
- EXPECT_NE(joined, copy);
- }
- }
- // A RepeatingCallback will implicitly convert to a OnceCallback, so a
- // once_callback.Then(repeating_callback) should turn into a OnceCallback
- // that holds 2 OnceCallbacks which it will run.
- TEST_F(CallbackTest, ThenCanConvertRepeatingToOnce) {
- {
- RepeatingClosure repeating_closure = base::BindRepeating([]() {});
- OnceClosure once_closure = base::BindOnce([]() {});
- std::move(once_closure).Then(repeating_closure).Run();
- RepeatingCallback<int(int)> repeating_callback =
- base::BindRepeating([](int i) { return i + 1; });
- OnceCallback<int(int)> once_callback =
- base::BindOnce([](int i) { return i * 2; });
- EXPECT_EQ(3, std::move(once_callback).Then(repeating_callback).Run(1));
- }
- {
- RepeatingClosure repeating_closure = base::BindRepeating([]() {});
- OnceClosure once_closure = base::BindOnce([]() {});
- std::move(once_closure).Then(std::move(repeating_closure)).Run();
- RepeatingCallback<int(int)> repeating_callback =
- base::BindRepeating([](int i) { return i + 1; });
- OnceCallback<int(int)> once_callback =
- base::BindOnce([](int i) { return i * 2; });
- EXPECT_EQ(
- 3, std::move(once_callback).Then(std::move(repeating_callback)).Run(1));
- }
- }
- // `Then()` should should allow a return value of type `R` to be passed to a
- // callback with one parameter of type `const R&` or type `R&&`.
- TEST_F(CallbackTest, ThenWithCompatibleButNotSameType) {
- {
- OnceCallback<std::string()> once_callback =
- BindOnce([] { return std::string("hello"); });
- EXPECT_EQ("hello",
- std::move(once_callback)
- .Then(BindOnce([](const std::string& s) { return s; }))
- .Run());
- }
- class NotCopied {
- public:
- NotCopied() = default;
- NotCopied(NotCopied&&) = default;
- NotCopied& operator=(NotCopied&&) = default;
- NotCopied(const NotCopied&) {
- ADD_FAILURE() << "should not have been copied";
- }
- NotCopied& operator=(const NotCopied&) {
- ADD_FAILURE() << "should not have been copied";
- return *this;
- }
- };
- {
- OnceCallback<NotCopied()> once_callback =
- BindOnce([] { return NotCopied(); });
- std::move(once_callback).Then(BindOnce([](const NotCopied&) {})).Run();
- }
- {
- OnceCallback<NotCopied()> once_callback =
- BindOnce([] { return NotCopied(); });
- std::move(once_callback).Then(BindOnce([](NotCopied&&) {})).Run();
- }
- }
- // A factory class for building an outer and inner callback for calling
- // Then() on either a OnceCallback or RepeatingCallback with combinations of
- // void return types, non-void, and move-only return types.
- template <bool use_once, typename R, typename ThenR, typename... Args>
- class CallbackThenTest;
- template <bool use_once, typename R, typename ThenR, typename... Args>
- class CallbackThenTest<use_once, R(Args...), ThenR> {
- public:
- using CallbackType =
- typename std::conditional<use_once,
- OnceCallback<R(Args...)>,
- RepeatingCallback<R(Args...)>>::type;
- using ThenType =
- typename std::conditional<use_once, OnceClosure, RepeatingClosure>::type;
- // Gets the Callback that will have Then() called on it. Has a return type
- // of `R`, which would chain to the inner callback for Then(). Has inputs of
- // type `Args...`.
- static auto GetOuter(std::string& s) {
- s = "";
- return Bind(
- [](std::string* s, Args... args) {
- return Outer(s, std::forward<Args>(args)...);
- },
- &s);
- }
- // Gets the Callback that will be passed to Then(). Has a return type of
- // `ThenR`, specified for the class instance. Receives as input the return
- // type `R` from the function bound and returned in GetOuter().
- static auto GetInner(std::string& s) { return Bind(&Inner<R, ThenR>, &s); }
- private:
- template <bool bind_once = use_once,
- typename F,
- typename... FArgs,
- std::enable_if_t<bind_once, int> = 0>
- static auto Bind(F function, FArgs... args) {
- return BindOnce(function, std::forward<FArgs>(args)...);
- }
- template <bool bind_once = use_once,
- typename F,
- typename... FArgs,
- std::enable_if_t<!bind_once, int> = 0>
- static auto Bind(F function, FArgs... args) {
- return BindRepeating(function, std::forward<FArgs>(args)...);
- }
- template <typename R2 = R,
- std::enable_if_t<!std::is_void<R2>::value, int> = 0>
- static int Outer(std::string* s,
- std::unique_ptr<int> a,
- std::unique_ptr<int> b) {
- *s += "Outer";
- *s += base::NumberToString(*a) + base::NumberToString(*b);
- return *a + *b;
- }
- template <typename R2 = R,
- std::enable_if_t<!std::is_void<R2>::value, int> = 0>
- static int Outer(std::string* s, int a, int b) {
- *s += "Outer";
- *s += base::NumberToString(a) + base::NumberToString(b);
- return a + b;
- }
- template <typename R2 = R,
- std::enable_if_t<!std::is_void<R2>::value, int> = 0>
- static int Outer(std::string* s) {
- *s += "Outer";
- *s += "None";
- return 99;
- }
- template <typename R2 = R, std::enable_if_t<std::is_void<R2>::value, int> = 0>
- static void Outer(std::string* s,
- std::unique_ptr<int> a,
- std::unique_ptr<int> b) {
- *s += "Outer";
- *s += base::NumberToString(*a) + base::NumberToString(*b);
- }
- template <typename R2 = R, std::enable_if_t<std::is_void<R2>::value, int> = 0>
- static void Outer(std::string* s, int a, int b) {
- *s += "Outer";
- *s += base::NumberToString(a) + base::NumberToString(b);
- }
- template <typename R2 = R, std::enable_if_t<std::is_void<R2>::value, int> = 0>
- static void Outer(std::string* s) {
- *s += "Outer";
- *s += "None";
- }
- template <typename OuterR,
- typename InnerR,
- std::enable_if_t<!std::is_void<OuterR>::value, int> = 0,
- std::enable_if_t<!std::is_void<InnerR>::value, int> = 0>
- static int Inner(std::string* s, OuterR a) {
- static_assert(std::is_same<InnerR, int>::value, "Use int return type");
- *s += "Inner";
- *s += base::NumberToString(a);
- return a;
- }
- template <typename OuterR,
- typename InnerR,
- std::enable_if_t<std::is_void<OuterR>::value, int> = 0,
- std::enable_if_t<!std::is_void<InnerR>::value, int> = 0>
- static int Inner(std::string* s) {
- static_assert(std::is_same<InnerR, int>::value, "Use int return type");
- *s += "Inner";
- *s += "None";
- return 99;
- }
- template <typename OuterR,
- typename InnerR,
- std::enable_if_t<!std::is_void<OuterR>::value, int> = 0,
- std::enable_if_t<std::is_void<InnerR>::value, int> = 0>
- static void Inner(std::string* s, OuterR a) {
- *s += "Inner";
- *s += base::NumberToString(a);
- }
- template <typename OuterR,
- typename InnerR,
- std::enable_if_t<std::is_void<OuterR>::value, int> = 0,
- std::enable_if_t<std::is_void<InnerR>::value, int> = 0>
- static void Inner(std::string* s) {
- *s += "Inner";
- *s += "None";
- }
- };
- template <typename R, typename ThenR = void, typename... Args>
- using CallbackThenOnceTest = CallbackThenTest<true, R, ThenR, Args...>;
- template <typename R, typename ThenR = void, typename... Args>
- using CallbackThenRepeatingTest = CallbackThenTest<false, R, ThenR, Args...>;
- TEST_F(CallbackTest, ThenOnce) {
- std::string s;
- // Void return from outer + void return from Then().
- {
- using VoidReturnWithoutArgs = void();
- using ThenReturn = void;
- using Test = CallbackThenOnceTest<VoidReturnWithoutArgs, ThenReturn>;
- Test::GetOuter(s).Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInnerNone");
- }
- {
- using VoidReturnWithArgs = void(int, int);
- using ThenReturn = void;
- using Test = CallbackThenOnceTest<VoidReturnWithArgs, ThenReturn>;
- Test::GetOuter(s).Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12InnerNone");
- }
- {
- using VoidReturnWithMoveOnlyArgs =
- void(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = void;
- using Test = CallbackThenOnceTest<VoidReturnWithMoveOnlyArgs, ThenReturn>;
- Test::GetOuter(s)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12InnerNone");
- }
- // Void return from outer + non-void return from Then().
- {
- using VoidReturnWithoutArgs = void();
- using ThenReturn = int;
- using Test = CallbackThenOnceTest<VoidReturnWithoutArgs, ThenReturn>;
- EXPECT_EQ(99, Test::GetOuter(s).Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInnerNone");
- }
- {
- using VoidReturnWithArgs = void(int, int);
- using ThenReturn = int;
- using Test = CallbackThenOnceTest<VoidReturnWithArgs, ThenReturn>;
- EXPECT_EQ(99, Test::GetOuter(s).Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12InnerNone");
- }
- {
- using VoidReturnWithMoveOnlyArgs =
- void(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = int;
- using Test = CallbackThenOnceTest<VoidReturnWithMoveOnlyArgs, ThenReturn>;
- EXPECT_EQ(99, Test::GetOuter(s)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12InnerNone");
- }
- // Non-void return from outer + void return from Then().
- {
- using NonVoidReturnWithoutArgs = int();
- using ThenReturn = void;
- using Test = CallbackThenOnceTest<NonVoidReturnWithoutArgs, ThenReturn>;
- Test::GetOuter(s).Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInner99");
- }
- {
- using NonVoidReturnWithArgs = int(int, int);
- using ThenReturn = void;
- using Test = CallbackThenOnceTest<NonVoidReturnWithArgs, ThenReturn>;
- Test::GetOuter(s).Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12Inner3");
- }
- {
- using NonVoidReturnWithMoveOnlyArgs =
- int(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = void;
- using Test =
- CallbackThenOnceTest<NonVoidReturnWithMoveOnlyArgs, ThenReturn>;
- Test::GetOuter(s)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12Inner3");
- }
- // Non-void return from outer + non-void return from Then().
- {
- using NonVoidReturnWithoutArgs = int();
- using ThenReturn = int;
- using Test = CallbackThenOnceTest<NonVoidReturnWithoutArgs, ThenReturn>;
- EXPECT_EQ(99, Test::GetOuter(s).Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInner99");
- }
- {
- using NonVoidReturnWithArgs = int(int, int);
- using ThenReturn = int;
- using Test = CallbackThenOnceTest<NonVoidReturnWithArgs, ThenReturn>;
- EXPECT_EQ(3, Test::GetOuter(s).Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12Inner3");
- }
- {
- using NonVoidReturnWithMoveOnlyArgs =
- int(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = int;
- using Test =
- CallbackThenOnceTest<NonVoidReturnWithMoveOnlyArgs, ThenReturn>;
- EXPECT_EQ(3, Test::GetOuter(s)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12Inner3");
- }
- }
- TEST_F(CallbackTest, ThenRepeating) {
- std::string s;
- // Void return from outer + void return from Then().
- {
- using VoidReturnWithoutArgs = void();
- using ThenReturn = void;
- using Test = CallbackThenRepeatingTest<VoidReturnWithoutArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInnerNone");
- std::move(outer).Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInnerNoneOuterNoneInnerNone");
- }
- {
- using VoidReturnWithArgs = void(int, int);
- using ThenReturn = void;
- using Test = CallbackThenRepeatingTest<VoidReturnWithArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12InnerNone");
- std::move(outer).Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12InnerNoneOuter12InnerNone");
- }
- {
- using VoidReturnWithMoveOnlyArgs =
- void(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = void;
- using Test =
- CallbackThenRepeatingTest<VoidReturnWithMoveOnlyArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12InnerNone");
- std::move(outer)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12InnerNoneOuter12InnerNone");
- }
- // Void return from outer + non-void return from Then().
- {
- using VoidReturnWithoutArgs = void();
- using ThenReturn = int;
- using Test = CallbackThenRepeatingTest<VoidReturnWithoutArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(99, outer.Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInnerNone");
- EXPECT_EQ(99, std::move(outer).Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInnerNoneOuterNoneInnerNone");
- }
- {
- using VoidReturnWithArgs = void(int, int);
- using ThenReturn = int;
- using Test = CallbackThenRepeatingTest<VoidReturnWithArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(99, outer.Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12InnerNone");
- EXPECT_EQ(99, std::move(outer).Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12InnerNoneOuter12InnerNone");
- }
- {
- using VoidReturnWithMoveOnlyArgs =
- void(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = int;
- using Test =
- CallbackThenRepeatingTest<VoidReturnWithMoveOnlyArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(99, outer.Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12InnerNone");
- EXPECT_EQ(99, std::move(outer)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12InnerNoneOuter12InnerNone");
- }
- // Non-void return from outer + void return from Then().
- {
- using NonVoidReturnWithoutArgs = int();
- using ThenReturn = void;
- using Test =
- CallbackThenRepeatingTest<NonVoidReturnWithoutArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInner99");
- std::move(outer).Then(Test::GetInner(s)).Run();
- EXPECT_EQ(s, "OuterNoneInner99OuterNoneInner99");
- }
- {
- using NonVoidReturnWithArgs = int(int, int);
- using ThenReturn = void;
- using Test = CallbackThenRepeatingTest<NonVoidReturnWithArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12Inner3");
- std::move(outer).Then(Test::GetInner(s)).Run(1, 2);
- EXPECT_EQ(s, "Outer12Inner3Outer12Inner3");
- }
- {
- using NonVoidReturnWithMoveOnlyArgs =
- int(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = void;
- using Test =
- CallbackThenRepeatingTest<NonVoidReturnWithMoveOnlyArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- outer.Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12Inner3");
- std::move(outer)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2));
- EXPECT_EQ(s, "Outer12Inner3Outer12Inner3");
- }
- // Non-void return from outer + non-void return from Then().
- {
- using NonVoidReturnWithoutArgs = int();
- using ThenReturn = int;
- using Test =
- CallbackThenRepeatingTest<NonVoidReturnWithoutArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(99, outer.Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInner99");
- EXPECT_EQ(99, std::move(outer).Then(Test::GetInner(s)).Run());
- EXPECT_EQ(s, "OuterNoneInner99OuterNoneInner99");
- }
- {
- using NonVoidReturnWithArgs = int(int, int);
- using ThenReturn = int;
- using Test = CallbackThenRepeatingTest<NonVoidReturnWithArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(3, outer.Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12Inner3");
- EXPECT_EQ(3, std::move(outer).Then(Test::GetInner(s)).Run(1, 2));
- EXPECT_EQ(s, "Outer12Inner3Outer12Inner3");
- }
- {
- using NonVoidReturnWithMoveOnlyArgs =
- int(std::unique_ptr<int>, std::unique_ptr<int>);
- using ThenReturn = int;
- using Test =
- CallbackThenRepeatingTest<NonVoidReturnWithMoveOnlyArgs, ThenReturn>;
- auto outer = Test::GetOuter(s);
- EXPECT_EQ(3, outer.Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12Inner3");
- EXPECT_EQ(3, std::move(outer)
- .Then(Test::GetInner(s))
- .Run(std::make_unique<int>(1), std::make_unique<int>(2)));
- EXPECT_EQ(s, "Outer12Inner3Outer12Inner3");
- }
- }
- // WeakPtr detection in BindRepeating() requires a method, not just any
- // function.
- class ClassWithAMethod {
- public:
- void TheMethod() { method_called = true; }
- bool method_called = false;
- };
- TEST_F(CallbackTest, MaybeValidInvalidateWeakPtrsOnSameSequence) {
- ClassWithAMethod obj;
- WeakPtrFactory<ClassWithAMethod> factory(&obj);
- WeakPtr<ClassWithAMethod> ptr = factory.GetWeakPtr();
- RepeatingCallback<void()> cb =
- BindRepeating(&ClassWithAMethod::TheMethod, ptr);
- EXPECT_TRUE(cb.MaybeValid());
- EXPECT_FALSE(cb.IsCancelled());
- factory.InvalidateWeakPtrs();
- // MaybeValid() should be false and IsCancelled() should become true because
- // InvalidateWeakPtrs() was called on the same thread.
- EXPECT_FALSE(cb.MaybeValid());
- EXPECT_TRUE(cb.IsCancelled());
- // is_null() is not affected by the invalidated WeakPtr.
- EXPECT_FALSE(cb.is_null());
- }
- TEST_F(CallbackTest, MaybeValidInvalidateWeakPtrsOnOtherSequence) {
- ClassWithAMethod obj;
- WeakPtrFactory<ClassWithAMethod> factory(&obj);
- WeakPtr<ClassWithAMethod> ptr = factory.GetWeakPtr();
- RepeatingCallback<void()> cb =
- BindRepeating(&ClassWithAMethod::TheMethod, ptr);
- EXPECT_TRUE(cb.MaybeValid());
- Thread other_thread("other_thread");
- other_thread.StartAndWaitForTesting();
- other_thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RepeatingCallback<void()> cb) {
- // Check that MaybeValid() _eventually_ returns false.
- const TimeDelta timeout = TestTimeouts::tiny_timeout();
- const TimeTicks begin = TimeTicks::Now();
- while (cb.MaybeValid() && (TimeTicks::Now() - begin) < timeout)
- PlatformThread::YieldCurrentThread();
- EXPECT_FALSE(cb.MaybeValid());
- },
- cb));
- factory.InvalidateWeakPtrs();
- // |other_thread|'s destructor will join, ensuring we wait for the task to be
- // run.
- }
- TEST_F(CallbackTest, ThenAfterWeakPtr) {
- ClassWithAMethod obj;
- WeakPtrFactory<ClassWithAMethod> factory(&obj);
- WeakPtr<ClassWithAMethod> ptr = factory.GetWeakPtr();
- // If the first callback of a chain is skipped due to InvalidateWeakPtrs(),
- // the remaining callbacks should still run.
- bool chained_closure_called = false;
- OnceClosure closure =
- BindOnce(&ClassWithAMethod::TheMethod, ptr)
- .Then(BindLambdaForTesting(
- [&chained_closure_called] { chained_closure_called = true; }));
- factory.InvalidateWeakPtrs();
- std::move(closure).Run();
- EXPECT_FALSE(obj.method_called);
- EXPECT_TRUE(chained_closure_called);
- }
- class CallbackOwner : public base::RefCounted<CallbackOwner> {
- public:
- explicit CallbackOwner(bool* deleted) {
- // WrapRefCounted() here is needed to avoid the check failure in the
- // BindRepeating implementation, that refuses to create the first reference
- // to ref-counted objects.
- callback_ = BindRepeating(&CallbackOwner::Unused, WrapRefCounted(this));
- deleted_ = deleted;
- }
- void Reset() {
- callback_.Reset();
- // We are deleted here if no-one else had a ref to us.
- }
- private:
- friend class base::RefCounted<CallbackOwner>;
- virtual ~CallbackOwner() {
- *deleted_ = true;
- }
- void Unused() {
- FAIL() << "Should never be called";
- }
- RepeatingClosure callback_;
- raw_ptr<bool> deleted_;
- };
- TEST_F(CallbackTest, CallbackHasLastRefOnContainingObject) {
- bool deleted = false;
- CallbackOwner* owner = new CallbackOwner(&deleted);
- owner->Reset();
- ASSERT_TRUE(deleted);
- }
- } // namespace
- } // namespace base
|