diff options
Diffstat (limited to 'chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h')
-rw-r--r-- | chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h | 112 |
1 files changed, 75 insertions, 37 deletions
diff --git a/chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h b/chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h index 812ac5b4908..33f4aedcf6a 100644 --- a/chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h +++ b/chromium/third_party/blink/renderer/modules/webgpu/dawn_callback.h @@ -17,8 +17,8 @@ namespace blink { // void* and passed to Dawn C callbacks. // // Example: -// DawnCallback<F>* callback = -// CreateDawnCallback(WTF::Bind(func, arg1)); +// DawnOnceCallback<F>* callback = +// BindDawnOnceCallback(func, arg1); // // // |someDawnFunction| expects callback function with arguments: // // Args... args, void* userdata. @@ -26,81 +26,119 @@ namespace blink { // GetProcs().someDawnFunction( // callback->UnboundCallback(), callback->AsUserdata()); template <typename Callback> -class DawnCallback; +class DawnCallbackBase; + +template <typename Callback> +class DawnOnceCallback; + +template <typename Callback> +class DawnRepeatingCallback; template <template <typename> class BaseCallbackTemplate, typename R, typename... Args> -class DawnCallback<BaseCallbackTemplate<R(Args...)>> { +class DawnCallbackBase<BaseCallbackTemplate<R(Args...)>> { using BaseCallback = BaseCallbackTemplate<R(Args...)>; - using UnboundCallbackFunction = R (*)(Args..., void*); + static constexpr bool is_once_callback = + std::is_same<BaseCallback, base::OnceCallback<R(Args...)>>::value; + static constexpr bool is_repeating_callback = + std::is_same<BaseCallback, base::RepeatingCallback<R(Args...)>>::value; static_assert( - std::is_same<BaseCallback, base::OnceCallback<R(Args...)>>::value || - std::is_same<BaseCallback, - base::RepeatingCallback<R(Args...)>>::value, + is_once_callback || is_repeating_callback, "Callback must be base::OnceCallback or base::RepeatingCallback"); public: - explicit DawnCallback(BaseCallback callback) + explicit DawnCallbackBase(BaseCallback callback) : callback_(std::move(callback)) {} + void* AsUserdata() { return static_cast<void*>(this); } + + protected: + using UnboundCallbackFunction = R (*)(Args..., void*); + + static DawnCallbackBase* FromUserdata(void* userdata) { + return static_cast<DawnCallbackBase*>(userdata); + } + R Run(Args... args) && { + static_assert( + is_once_callback, + "Run on a moved receiver must only be called on a once callback."); return std::move(callback_).Run(std::forward<Args>(args)...); } R Run(Args... args) const& { + static_assert(is_repeating_callback, + "Run on a unmoved receiver must only be called on a " + "repeating callback."); return callback_.Run(std::forward<Args>(args)...); } - void Reset() { callback_.Reset(); } + private: + BaseCallback callback_; +}; + +template <typename R, typename... Args> +class DawnOnceCallback<R(Args...)> + : public DawnCallbackBase<base::OnceCallback<R(Args...)>> { + using BaseCallback = base::OnceCallback<R(Args...)>; + + public: + using DawnCallbackBase<BaseCallback>::DawnCallbackBase; - static R CallUnboundCallback(Args... args, void* handle) { + typename DawnCallbackBase<BaseCallback>::UnboundCallbackFunction + UnboundCallback() { + return CallUnboundOnceCallback; + } + + private: + static R CallUnboundOnceCallback(Args... args, void* handle) { // After this non-repeating callback is run, it should delete itself. auto callback = - std::unique_ptr<DawnCallback>(DawnCallback::FromUserdata(handle)); + std::unique_ptr<DawnOnceCallback>(static_cast<DawnOnceCallback*>( + DawnCallbackBase<BaseCallback>::FromUserdata(handle))); return std::move(*callback).Run(std::forward<Args>(args)...); } +}; - static R CallUnboundRepeatingCallback(Args... args, void* handle) { - return DawnCallback::FromUserdata(handle)->Run(std::forward<Args>(args)...); - } +template <typename R, typename... Args> +class DawnRepeatingCallback<R(Args...)> + : public DawnCallbackBase<base::RepeatingCallback<R(Args...)>> { + using BaseCallback = base::RepeatingCallback<R(Args...)>; - UnboundCallbackFunction UnboundCallback() { return CallUnboundCallback; } + public: + using DawnCallbackBase<BaseCallback>::DawnCallbackBase; - UnboundCallbackFunction UnboundRepeatingCallback() { + typename DawnCallbackBase<BaseCallback>::UnboundCallbackFunction + UnboundCallback() { return CallUnboundRepeatingCallback; } - void* AsUserdata() { return static_cast<void*>(this); } - - static DawnCallback* FromUserdata(void* userdata) { - return static_cast<DawnCallback*>(userdata); - } - private: - BaseCallback callback_; + static R CallUnboundRepeatingCallback(Args... args, void* handle) { + return static_cast<DawnRepeatingCallback*>( + DawnCallbackBase<BaseCallback>::FromUserdata(handle)) + ->Run(std::forward<Args>(args)...); + } }; -template <typename CallbackType> -DawnCallback<CallbackType>* CreateDawnCallback(CallbackType cb) { - return new DawnCallback<CallbackType>(std::move(cb)); -} - template <typename FunctionType, typename... BoundParameters> -auto BindDawnCallback(FunctionType&& function, - BoundParameters&&... bound_parameters) { - return CreateDawnCallback( - WTF::Bind(std::forward<FunctionType>(function), - std::forward<BoundParameters>(bound_parameters)...)); +auto BindDawnOnceCallback(FunctionType&& function, + BoundParameters&&... bound_parameters) { + auto cb = WTF::Bind(std::forward<FunctionType>(function), + std::forward<BoundParameters>(bound_parameters)...); + return new DawnOnceCallback<typename decltype(cb)::RunType>(std::move(cb)); } template <typename FunctionType, typename... BoundParameters> -auto BindRepeatingDawnCallback(FunctionType&& function, +auto BindDawnRepeatingCallback(FunctionType&& function, BoundParameters&&... bound_parameters) { - return CreateDawnCallback( + auto cb = WTF::BindRepeating(std::forward<FunctionType>(function), - std::forward<BoundParameters>(bound_parameters)...)); + std::forward<BoundParameters>(bound_parameters)...); + return std::make_unique< + DawnRepeatingCallback<typename decltype(cb)::RunType>>(std::move(cb)); } } // namespace blink |