Revert "Bug 1977019 - re-enable hw video decoding testing. r=media-playback-reviewers,jolin" for causing win mda failures on test_hw_video_decoding.html
This reverts commit 158474bdc0cf585b701bc47921f0a7d84f7bb84d.
// Copyright 2012 The Chromium Authors// Use of this source code is governed by a BSD-style license that can be// found in the LICENSE file.//// NOTE: Header files that do not require the full definition of// base::{Once,Repeating}Callback or base::{Once,Repeating}Closure should// #include "base/functional/callback_forward.h" instead of this file.#ifndef BASE_FUNCTIONAL_CALLBACK_H_#define BASE_FUNCTIONAL_CALLBACK_H_#include<stddef.h>#include<utility>#include"base/check.h"#include"base/compiler_specific.h"#include"base/functional/bind.h"#include"base/functional/callback_forward.h" // IWYU pragma: export#include"base/functional/callback_internal.h"#include"base/functional/callback_tags.h"#include"base/functional/function_ref.h"#include"base/notreached.h"#include"base/types/always_false.h"// -----------------------------------------------------------------------------// Usage documentation// -----------------------------------------------------------------------------//// Overview:// A callback is similar in concept to a function pointer: it wraps a runnable// object such as a function, method, lambda, or even another callback, allowing// the runnable object to be invoked later via the callback object.//// Unlike function pointers, callbacks are created with base::BindOnce() or// base::BindRepeating() and support partial function application.//// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may// be Run() any number of times. |is_null()| is guaranteed to return true for a// moved-from callback.//// // The lambda takes two arguments, but the first argument |x| is bound at// // callback creation.// base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {// return x + y;// }, 1);// // Run() only needs the remaining unbound argument |y|.// printf("1 + 2 = %d\n", std::move(cb).Run(2)); // Prints 3// printf("cb is null? %s\n",// cb.is_null() ? "true" : "false"); // Prints true// std::move(cb).Run(2); // Crashes since |cb| has already run.//// Callbacks also support cancellation. A common use is binding the receiver// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()// will be a no-op. Note that |IsCancelled()| and |is_null()| are distinct:// simply cancelling a callback will not also make it null.//// See //docs/callback.md for the full documentation.namespacebase{namespaceinternal{template<boolis_once,typenameR,typename...UnboundArgs,typename...BoundArgs>autoToDoNothingCallback(DoNothingCallbackTag::WithBoundArguments<BoundArgs...>t);}// namespace internaltemplate<typenameR,typename...Args>classTRIVIAL_ABIOnceCallback<R(Args...)>{public:usingResultType=R;usingRunType=R(Args...);usingPolymorphicInvoke=R(*)(internal::BindStateBase*,internal::PassingType<Args>...);// Constructs a null `OnceCallback`. A null callback has no associated functor// and cannot be run.constexprOnceCallback()=default;// Disallowed to prevent ambiguity.OnceCallback(std::nullptr_t)=delete;// `OnceCallback` is not copyable since its bound functor may only run at most// once.OnceCallback(constOnceCallback&)=delete;OnceCallback&operator=(constOnceCallback&)=delete;// Subtle: since `this` is marked as TRIVIAL_ABI, the move operations// must leave the moved-from callback in a trivially destructible state.OnceCallback(OnceCallback&&)noexcept=default;OnceCallback&operator=(OnceCallback&&)noexcept=default;~OnceCallback()=default;// A `OnceCallback` is a strict subset of `RepeatingCallback`'s functionality,// so allow seamless conversion.// NOLINTNEXTLINE(google-explicit-constructor)OnceCallback(RepeatingCallback<RunType>other):holder_(std::move(other.holder_)){}OnceCallback&operator=(RepeatingCallback<RunType>other){holder_=std::move(other.holder_);return*this;}// Returns true if `this` is non-null and can be `Run()`.explicitoperatorbool()const{return!!holder_;}// Returns true if `this` is null and cannot be `Run()`.boolis_null()const{returnholder_.is_null();}// Returns true if calling `Run()` is a no-op because of cancellation.//// - Not thread-safe, i.e. must be called on the same sequence that will// ultimately `Run()` the callback// - May not be called on a null callback.boolIsCancelled()const{returnholder_.IsCancelled();}// Subtle version of `IsCancelled()` that allows cancellation state to be// queried from any sequence. May return true even if the callback has// actually been cancelled.//// Do not use. This is intended for internal //base usage.// TODO(dcheng): Restrict this since it, in fact, being used outside of its// originally intended use.boolMaybeValid()const{returnholder_.MaybeValid();}// Resets this to a null state.REINITIALIZES_AFTER_MOVEvoidReset(){holder_.Reset();}// Non-consuming `Run()` is disallowed for `OnceCallback`.RRun(Args...args)const&{static_assert(!sizeof(*this),"OnceCallback::Run() may only be invoked on a non-const ""rvalue, i.e. std::move(callback).Run().");NOTREACHED();}// Calls the bound functor with any already-bound arguments + `args`. Consumes// `this`, i.e. `this` becomes null.//// May not be called on a null callback.RRun(Args...args)&&{// Move the callback instance into a local variable before the invocation,// that ensures the internal state is cleared after the invocation.// It's not safe to touch |this| after the invocation, since running the// bound function may destroy |this|.internal::BindStateHolderholder=std::move(holder_);PolymorphicInvokef=reinterpret_cast<PolymorphicInvoke>(holder.polymorphic_invoke());returnf(holder.bind_state().get(),std::forward<Args>(args)...);}// Then() returns a new OnceCallback that receives the same arguments as// |this|, and with the return type of |then|. The returned callback will:// 1) Run the functor currently bound to |this| callback.// 2) Run the |then| callback with the result from step 1 as its single// argument.// 3) Return the value from running the |then| callback.//// Since this method generates a callback that is a replacement for `this`,// `this` will be consumed and reset to a null callback to ensure the// originally-bound functor can be run at most once.template<typenameThenR,typename...ThenArgs>OnceCallback<ThenR(Args...)>Then(OnceCallback<ThenR(ThenArgs...)>then)&&{CHECK(then);returnbase::BindOnce(internal::ThenHelper<OnceCallback,OnceCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),std::move(*this),std::move(then));}// This overload is required; even though RepeatingCallback is implicitly// convertible to OnceCallback, that conversion will not used when matching// for template argument deduction.template<typenameThenR,typename...ThenArgs>OnceCallback<ThenR(Args...)>Then(RepeatingCallback<ThenR(ThenArgs...)>then)&&{CHECK(then);returnbase::BindOnce(internal::ThenHelper<OnceCallback,RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),std::move(*this),std::move(then));}// Internal constructors for various callback helper tag types, e.g.// `base::DoNothing()`.// NOLINTNEXTLINE(google-explicit-constructor)constexprOnceCallback(internal::NullCallbackTag):OnceCallback(){}constexprOnceCallback&operator=(internal::NullCallbackTag){*this=OnceCallback();return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprOnceCallback(internal::NullCallbackTag::WithSignature<RunType>):OnceCallback(internal::NullCallbackTag()){}constexprOnceCallback&operator=(internal::NullCallbackTag::WithSignature<RunType>){*this=internal::NullCallbackTag();return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprOnceCallback(internal::DoNothingCallbackTag):OnceCallback(BindOnce([](Args...args){})){}constexprOnceCallback&operator=(internal::DoNothingCallbackTag){*this=BindOnce([](Args...args){});return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprOnceCallback(internal::DoNothingCallbackTag::WithSignature<RunType>):OnceCallback(internal::DoNothingCallbackTag()){}constexprOnceCallback&operator=(internal::DoNothingCallbackTag::WithSignature<RunType>){*this=internal::DoNothingCallbackTag();return*this;}template<typename...BoundArgs>// NOLINTNEXTLINE(google-explicit-constructor)constexprOnceCallback(internal::DoNothingCallbackTag::WithBoundArguments<BoundArgs...>tag):OnceCallback(internal::ToDoNothingCallback<true,R,Args...>(std::move(tag))){}template<typename...BoundArgs>constexprOnceCallback&operator=(internal::DoNothingCallbackTag::WithBoundArguments<BoundArgs...>tag){*this=internal::ToDoNothingCallback<true,R,Args...>(std::move(tag));return*this;}// Internal constructor for `base::BindOnce()`.explicitOnceCallback(internal::BindStateBase*bind_state):holder_(bind_state){}template<typenameSignature>// NOLINTNEXTLINE(google-explicit-constructor)operatorFunctionRef<Signature>()&{static_assert(AlwaysFalse<Signature>,"need to convert a base::OnceCallback to base::FunctionRef? ""Please bring up this use case on #cxx (Slack) or cxx@chromium.org.");}template<typenameSignature>// NOLINTNEXTLINE(google-explicit-constructor)operatorFunctionRef<Signature>()&&{static_assert(AlwaysFalse<Signature>,"using base::BindOnce() is not necessary with base::FunctionRef; is it ""possible to use a capturing lambda directly? If not, please bring up ""this use case on #cxx (Slack) or cxx@chromium.org.");}private:internal::BindStateHolderholder_;};template<typenameR,typename...Args>classTRIVIAL_ABIRepeatingCallback<R(Args...)>{public:usingResultType=R;usingRunType=R(Args...);usingPolymorphicInvoke=R(*)(internal::BindStateBase*,internal::PassingType<Args>...);// Constructs a null `RepeatingCallback`. A null callback has no associated// functor and cannot be run.constexprRepeatingCallback()=default;// Disallowed to prevent ambiguity.RepeatingCallback(std::nullptr_t)=delete;// Unlike a `OnceCallback`, a `RepeatingCallback` may be copied since its// bound functor may be run more than once.RepeatingCallback(constRepeatingCallback&)=default;RepeatingCallback&operator=(constRepeatingCallback&)=default;// Subtle: since `this` is marked as TRIVIAL_ABI, the move operations// must leave the moved-from callback in a trivially destructible state.RepeatingCallback(RepeatingCallback&&)noexcept=default;RepeatingCallback&operator=(RepeatingCallback&&)noexcept=default;~RepeatingCallback()=default;// Returns true if `this` is non-null and can be `Run()`.explicitoperatorbool()const{return!!holder_;}// Returns true if `this` is null and cannot be `Run()`.boolis_null()const{returnholder_.is_null();}// Returns true if calling `Run()` is a no-op because of cancellation.//// - Not thread-safe, i.e. must be called on the same sequence that will// ultimately `Run()` the callback// - May not be called on a null callback.boolIsCancelled()const{returnholder_.IsCancelled();}// Subtle version of `IsCancelled()` that allows cancellation state to be// queried from any sequence. May return true even if the callback has// actually been cancelled.//// Do not use. This is intended for internal //base usage.// TODO(dcheng): Restrict this since it, in fact, being used outside of its// originally intended use.boolMaybeValid()const{returnholder_.MaybeValid();}// Equality operators: two `RepeatingCallback`'s are equalbooloperator==(constRepeatingCallback&other)const{returnholder_==other.holder_;}booloperator!=(constRepeatingCallback&other)const{return!operator==(other);}// Resets this to null.REINITIALIZES_AFTER_MOVEvoidReset(){holder_.Reset();}// Calls the bound functor with any already-bound arguments + `args`. Does not// consume `this`, i.e. this remains non-null.//// May not be called on a null callback.RRun(Args...args)const&{// Keep `bind_state` alive at least until after the invocation to ensure all// bound `Unretained` arguments remain protected by MiraclePtr.scoped_refptr<internal::BindStateBase>bind_state=holder_.bind_state();PolymorphicInvokef=reinterpret_cast<PolymorphicInvoke>(holder_.polymorphic_invoke());returnf(bind_state.get(),std::forward<Args>(args)...);}// Calls the bound functor with any already-bound arguments + `args`. Consumes// `this`, i.e. `this` becomes null.//// May not be called on a null callback.RRun(Args...args)&&{// Move the callback instance into a local variable before the invocation,// that ensures the internal state is cleared after the invocation.// It's not safe to touch |this| after the invocation, since running the// bound function may destroy |this|.internal::BindStateHolderholder=std::move(holder_);PolymorphicInvokef=reinterpret_cast<PolymorphicInvoke>(holder.polymorphic_invoke());returnf(holder.bind_state().get(),std::forward<Args>(args)...);}// Then() returns a new RepeatingCallback that receives the same arguments as// |this|, and with the return type of |then|. The// returned callback will:// 1) Run the functor currently bound to |this| callback.// 2) Run the |then| callback with the result from step 1 as its single// argument.// 3) Return the value from running the |then| callback.//// If called on an rvalue (e.g. std::move(cb).Then(...)), this method// generates a callback that is a replacement for `this`. Therefore, `this`// will be consumed and reset to a null callback to ensure the// originally-bound functor will be run at most once.template<typenameThenR,typename...ThenArgs>RepeatingCallback<ThenR(Args...)>Then(RepeatingCallback<ThenR(ThenArgs...)>then)const&{CHECK(then);returnBindRepeating(internal::ThenHelper<RepeatingCallback,RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),*this,std::move(then));}template<typenameThenR,typename...ThenArgs>RepeatingCallback<ThenR(Args...)>Then(RepeatingCallback<ThenR(ThenArgs...)>then)&&{CHECK(then);returnBindRepeating(internal::ThenHelper<RepeatingCallback,RepeatingCallback<ThenR(ThenArgs...)>>::CreateTrampoline(),std::move(*this),std::move(then));}// Internal constructors for various callback helper tag types, e.g.// `base::DoNothing()`.// NOLINTNEXTLINE(google-explicit-constructor)constexprRepeatingCallback(internal::NullCallbackTag):RepeatingCallback(){}constexprRepeatingCallback&operator=(internal::NullCallbackTag){*this=RepeatingCallback();return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprRepeatingCallback(internal::NullCallbackTag::WithSignature<RunType>):RepeatingCallback(internal::NullCallbackTag()){}constexprRepeatingCallback&operator=(internal::NullCallbackTag::WithSignature<RunType>){*this=internal::NullCallbackTag();return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprRepeatingCallback(internal::DoNothingCallbackTag):RepeatingCallback(BindRepeating([](Args...args){})){}constexprRepeatingCallback&operator=(internal::DoNothingCallbackTag){*this=BindRepeating([](Args...args){});return*this;}// NOLINTNEXTLINE(google-explicit-constructor)constexprRepeatingCallback(internal::DoNothingCallbackTag::WithSignature<RunType>):RepeatingCallback(internal::DoNothingCallbackTag()){}constexprRepeatingCallback&operator=(internal::DoNothingCallbackTag::WithSignature<RunType>){*this=internal::DoNothingCallbackTag();return*this;}template<typename...BoundArgs>// NOLINTNEXTLINE(google-explicit-constructor)constexprRepeatingCallback(internal::DoNothingCallbackTag::WithBoundArguments<BoundArgs...>tag):RepeatingCallback(internal::ToDoNothingCallback<false,R,Args...>(std::move(tag))){}template<typename...BoundArgs>constexprRepeatingCallback&operator=(internal::DoNothingCallbackTag::WithBoundArguments<BoundArgs...>tag){*this=internal::ToDoNothingCallback<false,R,Args...>(std::move(tag));returnthis;}// Internal constructor for `base::BindRepeating()`.explicitRepeatingCallback(internal::BindStateBase*bind_state):holder_(bind_state){}template<typenameSignature>// NOLINTNEXTLINE(google-explicit-constructor)operatorFunctionRef<Signature>()&{static_assert(AlwaysFalse<Signature>,"need to convert a base::RepeatingCallback to base::FunctionRef? ""Please bring up this use case on #cxx (Slack) or cxx@chromium.org.");}template<typenameSignature>// NOLINTNEXTLINE(google-explicit-constructor)operatorFunctionRef<Signature>()&&{static_assert(AlwaysFalse<Signature>,"using base::BindRepeating() is not necessary with base::FunctionRef; ""is it possible to use a capturing lambda directly? If not, please ""bring up this use case on #cxx (Slack) or cxx@chromium.org.");}private:friendclassOnceCallback<R(Args...)>;internal::BindStateHolderholder_;};namespaceinternal{// Helper for the `DoNothingWithBoundArgs()` implementation.// Unlike the other helpers, this cannot be easily moved to callback_internal.h,// since it depends on `BindOnce()` and `BindRepeating()`.template<boolis_once,typenameR,typename...UnboundArgs,typename...BoundArgs>autoToDoNothingCallback(DoNothingCallbackTag::WithBoundArguments<BoundArgs...>t){returnstd::apply([](auto&&...args){ifconstexpr(is_once){returnBindOnce([](TransformToUnwrappedType<is_once,BoundArgs>...,UnboundArgs...){},std::move(args)...);}else{returnBindRepeating([](TransformToUnwrappedType<is_once,BoundArgs>...,UnboundArgs...){},std::move(args)...);}},std::move(t.bound_args));}}// namespace internal}// namespace base#endif // BASE_FUNCTIONAL_CALLBACK_H_