summaryrefslogtreecommitdiffstats
path: root/chromium/base/task/promise/then_and_catch_executor.h
diff options
context:
space:
mode:
Diffstat (limited to 'chromium/base/task/promise/then_and_catch_executor.h')
-rw-r--r--chromium/base/task/promise/then_and_catch_executor.h87
1 files changed, 49 insertions, 38 deletions
diff --git a/chromium/base/task/promise/then_and_catch_executor.h b/chromium/base/task/promise/then_and_catch_executor.h
index 56d30ba2a11..7668fc1fbcb 100644
--- a/chromium/base/task/promise/then_and_catch_executor.h
+++ b/chromium/base/task/promise/then_and_catch_executor.h
@@ -17,11 +17,11 @@ namespace internal {
// Exists to reduce template bloat.
class BASE_EXPORT ThenAndCatchExecutorCommon {
public:
- ThenAndCatchExecutorCommon(internal::CallbackBase&& resolve_executor,
- internal::CallbackBase&& reject_executor) noexcept
- : resolve_callback_(std::move(resolve_executor)),
- reject_callback_(std::move(reject_executor)) {
- DCHECK(!resolve_callback_.is_null() || !reject_callback_.is_null());
+ ThenAndCatchExecutorCommon(internal::CallbackBase&& then_callback,
+ internal::CallbackBase&& catch_callback) noexcept
+ : then_callback_(std::move(then_callback)),
+ catch_callback_(std::move(catch_callback)) {
+ DCHECK(!then_callback_.is_null() || !catch_callback_.is_null());
}
~ThenAndCatchExecutorCommon() = default;
@@ -44,24 +44,23 @@ class BASE_EXPORT ThenAndCatchExecutorCommon {
AbstractPromise* arg,
AbstractPromise* result);
- CallbackBase resolve_callback_;
- CallbackBase reject_callback_;
+ CallbackBase then_callback_;
+ CallbackBase catch_callback_;
};
// Tag signals no callback which is used to eliminate dead code.
struct NoCallback {};
-template <typename ResolveOnceCallback,
- typename RejectOnceCallback,
+template <typename ThenOnceCallback,
+ typename CatchOnceCallback,
typename ArgResolve,
typename ArgReject,
typename ResolveStorage,
typename RejectStorage>
class ThenAndCatchExecutor {
public:
- using ResolveReturnT =
- typename CallbackTraits<ResolveOnceCallback>::ReturnType;
- using RejectReturnT = typename CallbackTraits<RejectOnceCallback>::ReturnType;
+ using ThenReturnT = typename CallbackTraits<ThenOnceCallback>::ReturnType;
+ using CatchReturnT = typename CallbackTraits<CatchOnceCallback>::ReturnType;
using PrerequisiteCouldResolve =
std::integral_constant<bool,
!std::is_same<ArgResolve, NoCallback>::value>;
@@ -69,8 +68,8 @@ class ThenAndCatchExecutor {
std::integral_constant<bool, !std::is_same<ArgReject, NoCallback>::value>;
ThenAndCatchExecutor(CallbackBase&& resolve_callback,
- CallbackBase&& reject_callback) noexcept
- : common_(std::move(resolve_callback), std::move(reject_callback)) {}
+ CallbackBase&& catch_callback) noexcept
+ : common_(std::move(resolve_callback), std::move(catch_callback)) {}
bool IsCancelled() const { return common_.IsCancelled(); }
@@ -85,29 +84,29 @@ class ThenAndCatchExecutor {
#if DCHECK_IS_ON()
PromiseExecutor::ArgumentPassingType ResolveArgumentPassingType() const {
- return common_.resolve_callback_.is_null()
+ return common_.then_callback_.is_null()
? PromiseExecutor::ArgumentPassingType::kNoCallback
- : CallbackTraits<ResolveOnceCallback>::argument_passing_type;
+ : CallbackTraits<ThenOnceCallback>::argument_passing_type;
}
PromiseExecutor::ArgumentPassingType RejectArgumentPassingType() const {
- return common_.reject_callback_.is_null()
+ return common_.catch_callback_.is_null()
? PromiseExecutor::ArgumentPassingType::kNoCallback
- : CallbackTraits<RejectOnceCallback>::argument_passing_type;
+ : CallbackTraits<CatchOnceCallback>::argument_passing_type;
}
bool CanResolve() const {
- return (!common_.resolve_callback_.is_null() &&
- PromiseCallbackTraits<ResolveReturnT>::could_resolve) ||
- (!common_.reject_callback_.is_null() &&
- PromiseCallbackTraits<RejectReturnT>::could_resolve);
+ return (!common_.then_callback_.is_null() &&
+ PromiseCallbackTraits<ThenReturnT>::could_resolve) ||
+ (!common_.catch_callback_.is_null() &&
+ PromiseCallbackTraits<CatchReturnT>::could_resolve);
}
bool CanReject() const {
- return (!common_.resolve_callback_.is_null() &&
- PromiseCallbackTraits<ResolveReturnT>::could_reject) ||
- (!common_.reject_callback_.is_null() &&
- PromiseCallbackTraits<RejectReturnT>::could_reject);
+ return (!common_.then_callback_.is_null() &&
+ PromiseCallbackTraits<ThenReturnT>::could_reject) ||
+ (!common_.catch_callback_.is_null() &&
+ PromiseCallbackTraits<CatchReturnT>::could_reject);
}
#endif
@@ -121,8 +120,8 @@ class ThenAndCatchExecutor {
static void ExecuteCatch(AbstractPromise* prerequisite,
AbstractPromise* promise,
- CallbackBase* reject_callback) {
- ExecuteCatchInternal(prerequisite, promise, reject_callback,
+ CallbackBase* catch_callback) {
+ ExecuteCatchInternal(prerequisite, promise, catch_callback,
PrerequisiteCouldReject());
}
@@ -130,10 +129,16 @@ class ThenAndCatchExecutor {
AbstractPromise* promise,
CallbackBase* resolve_callback,
std::true_type can_resolve) {
- RunHelper<ResolveOnceCallback, Resolved<ArgResolve>, ResolveStorage,
- RejectStorage>::
- Run(std::move(*static_cast<ResolveOnceCallback*>(resolve_callback)),
- prerequisite, promise);
+ // Internally RunHelper uses const RepeatingCallback<>& to avoid the
+ // binary size overhead of moving a scoped_refptr<> about. We respect
+ // the onceness of the callback and RunHelper will overwrite the callback
+ // with the result.
+ using RepeatingThenCB =
+ typename ToRepeatingCallback<ThenOnceCallback>::value;
+ RunHelper<
+ RepeatingThenCB, Resolved<ArgResolve>, ResolveStorage,
+ RejectStorage>::Run(*static_cast<RepeatingThenCB*>(resolve_callback),
+ prerequisite, promise);
}
static void ExecuteThenInternal(AbstractPromise* prerequisite,
@@ -145,17 +150,23 @@ class ThenAndCatchExecutor {
static void ExecuteCatchInternal(AbstractPromise* prerequisite,
AbstractPromise* promise,
- CallbackBase* reject_callback,
+ CallbackBase* catch_callback,
std::true_type can_reject) {
- RunHelper<RejectOnceCallback, Rejected<ArgReject>, ResolveStorage,
- RejectStorage>::
- Run(std::move(*static_cast<RejectOnceCallback*>(reject_callback)),
- prerequisite, promise);
+ // Internally RunHelper uses const RepeatingCallback<>& to avoid the
+ // binary size overhead of moving a scoped_refptr<> about. We respect
+ // the onceness of the callback and RunHelper will overwrite the callback
+ // with the result.
+ using RepeatingCatchCB =
+ typename ToRepeatingCallback<CatchOnceCallback>::value;
+ RunHelper<
+ RepeatingCatchCB, Rejected<ArgReject>, ResolveStorage,
+ RejectStorage>::Run(*static_cast<RepeatingCatchCB*>(catch_callback),
+ prerequisite, promise);
}
static void ExecuteCatchInternal(AbstractPromise* prerequisite,
AbstractPromise* promise,
- CallbackBase* reject_callback,
+ CallbackBase* catch_callback,
std::false_type can_reject) {
// |prerequisite| can't reject so don't generate dead code.
}