diff options
Diffstat (limited to 'chromium/base/task/promise/then_and_catch_executor.h')
-rw-r--r-- | chromium/base/task/promise/then_and_catch_executor.h | 87 |
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. } |