Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(912)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/bind.h

Issue 610313003: [WIP][Base] Use variadic template for Callback and Bind (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: wrap tuple Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « base/base.gypi ('k') | base/bind.h.pump » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/bind.h
diff --git a/base/bind.h b/base/bind.h
index b14f70c109f777ef78991990aedef270a2e82bc8..1c1358ed4b3451af495c5c7fa714fe934eb1da2a 100644
--- a/base/bind.h
+++ b/base/bind.h
@@ -1,8 +1,3 @@
-// This file was GENERATED by command:
-// pump.py bind.h.pump
-// DO NOT EDIT BY HAND!!!
-
-
// Copyright (c) 2011 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.
@@ -12,6 +7,7 @@
#include "base/bind_internal.h"
#include "base/callback_internal.h"
+#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
// -----------------------------------------------------------------------------
// Usage documentation
@@ -53,396 +49,83 @@
namespace base {
+namespace internal {
+
+// HasNonConstReferenceParam takes a function signature and returns true as
+// HasNonConstReferenceParam::value if any of its parameters is non-const
+// reference type.
+template <typename Sig>
+struct HasNonConstReferenceParam : false_type {};
+
+// Check if the first parameter is a non-const reference.
+// If not, skip the first parameter and check rest of parameters recursively.
+template <typename R, typename T, typename... Args>
+struct HasNonConstReferenceParam<R(T, Args...)>
+ : SelectType<is_non_const_reference<T>::value,
+ true_type,
+ HasNonConstReferenceParam<R(Args...)> >::Type {};
+
+// HasRefCountedParamAsRawPtr takes a function signature and return true as
+// HasRefCountedParamAsRawPtr::value if any of its parameter is a raw pointer to
+// a RefCounted type.
+template <typename Sig>
+struct HasRefCountedParamAsRawPtr : false_type {};
+
+// Check if the first parameter is a raw pointer to a RefCounted type.
+// If not, skip the first parameter and check rest of parameters recursively.
+template <typename R, typename T, typename... Args>
+struct HasRefCountedParamAsRawPtr<R(T, Args...)>
+ : SelectType<NeedsScopedRefptrButGetsRawPtr<T>::value,
+ true_type,
+ HasRefCountedParamAsRawPtr<R(Args...)> >::Type {};
+
+// UsesBannedBindingType takes a boolean to specify
+// a functor signature and a function signature and
+// returns true as UsesBannedBinding::value if any of the forbidden cases below
+// hits:
+// - Any of non-this pointer parameters is a raw pointer to a RefCounted type.
+// - The parameter for this pointer is an array.
+template <bool is_method, typename Signature>
+struct UsesBannedBindingType : HasRefCountedParamAsRawPtr<Signature> {};
+
+// Check if the first parameter of a method binding is an array.
+// If not, skip the first parameter and check if any of rest of parameters
+// is a raw pointer to a RefCounted type.
+template <typename R, typename T, typename... Args>
+struct UsesBannedBindingType<true, R(T, Args...)>
+ : SelectType<is_array<T>::value,
+ true_type,
+ HasRefCountedParamAsRawPtr<R(Args...)> >::Type {};
+
+} // namespace internal
+
template <typename Functor>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
- void()>
- ::UnboundRunType>
+ internal::TypeList<> >::UnboundRunType>
Bind(Functor functor) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
- typedef internal::BindState<RunnableType, RunType, void()> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor)));
-}
-
-template <typename Functor, typename P1>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
-
+ internal::TypeList<>> BindState;
return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1));
-}
-
-template <typename Functor, typename P1, typename P2>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2));
-}
-
-template <typename Functor, typename P1, typename P2, typename P3>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
- p3_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType)> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2, p3));
-}
-
-template <typename Functor, typename P1, typename P2, typename P3, typename P4>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
- p3_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
- p4_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType)> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4));
-}
-
-template <typename Functor, typename P1, typename P2, typename P3, typename P4,
- typename P5>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
- const P5& p5) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
- p3_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
- p4_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
- p5_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType)> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
-}
-
-template <typename Functor, typename P1, typename P2, typename P3, typename P4,
- typename P5, typename P6>
-base::Callback<
- typename internal::BindState<
- typename internal::FunctorTraits<Functor>::RunnableType,
- typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType,
- typename internal::CallbackParamTraits<P6>::StorageType)>
- ::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
- const P5& p5, const P6& p6) {
- // Typedefs for how to store and run the functor.
- typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
- typedef typename internal::FunctorTraits<Functor>::RunType RunType;
-
- // Use RunnableType::RunType instead of RunType above because our
- // checks should below for bound references need to know what the actual
- // functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
-
- // Do not allow binding a non-const reference parameter. Non-const reference
- // parameters are disallowed by the Google style guide. Also, binding a
- // non-const reference parameter can make for subtle bugs because the
- // invoked function will receive a reference to the stored copy of the
- // argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
-
- // For methods, we need to be careful for parameter 1. We do not require
- // a scoped_refptr because BindState<> itself takes care of AddRef() for
- // methods. We also disallow binding of an array as the method's target
- // object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
- p3_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
- p4_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
- p5_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
- p6_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType,
- typename internal::CallbackParamTraits<P6>::StorageType)> BindState;
-
-
- return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
+ new BindState(internal::MakeRunnable(functor)));
}
-template <typename Functor, typename P1, typename P2, typename P3, typename P4,
- typename P5, typename P6, typename P7>
+template <typename Functor, typename... Args>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType,
- typename internal::CallbackParamTraits<P6>::StorageType,
- typename internal::CallbackParamTraits<P7>::StorageType)>
+ internal::TypeList<
+ typename internal::CallbackParamTraits<Args>::StorageType...>>
::UnboundRunType>
-Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
- const P5& p5, const P6& p6, const P7& p7) {
+Bind(Functor functor, const Args&... args) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
@@ -450,60 +133,32 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// Use RunnableType::RunType instead of RunType above because our
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
- typedef internal::FunctionTraits<typename RunnableType::RunType>
- BoundFunctorTraits;
+ typedef typename RunnableType::RunType BoundRunType;
// Do not allow binding a non-const reference parameter. Non-const reference
// parameters are disallowed by the Google style guide. Also, binding a
// non-const reference parameter can make for subtle bugs because the
// invoked function will receive a reference to the stored copy of the
// argument and not the original.
- COMPILE_ASSERT(
- !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ||
- is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ),
- do_not_bind_functions_with_nonconst_ref);
+ COMPILE_ASSERT(!internal::HasNonConstReferenceParam<BoundRunType>::value,
+ do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
- COMPILE_ASSERT(
- internal::HasIsMethodTag<RunnableType>::value ||
- !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
- p1_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
- !is_array<P1>::value,
- first_bound_argument_to_method_cannot_be_array);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
- p2_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
- p3_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
- p4_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
- p5_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
- p6_is_refcounted_type_and_needs_scoped_refptr);
- COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
- p7_is_refcounted_type_and_needs_scoped_refptr);
- typedef internal::BindState<RunnableType, RunType,
- void(typename internal::CallbackParamTraits<P1>::StorageType,
- typename internal::CallbackParamTraits<P2>::StorageType,
- typename internal::CallbackParamTraits<P3>::StorageType,
- typename internal::CallbackParamTraits<P4>::StorageType,
- typename internal::CallbackParamTraits<P5>::StorageType,
- typename internal::CallbackParamTraits<P6>::StorageType,
- typename internal::CallbackParamTraits<P7>::StorageType)> BindState;
+ COMPILE_ASSERT((!internal::UsesBannedBindingType<
+ internal::HasIsMethodTag<RunnableType>::value, void(Args...)>::value),
+ this_param_is_a_array_or_a_param_is_raw_pointer_to_refcounted_type);
+ typedef internal::BindState<
+ RunnableType, RunType,
+ internal::TypeList<
+ typename internal::CallbackParamTraits<Args>::StorageType...>>
+ BindState;
return Callback<typename BindState::UnboundRunType>(
- new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
- p7));
+ new BindState(internal::MakeRunnable(functor), args...));
}
} // namespace base
« no previous file with comments | « base/base.gypi ('k') | base/bind.h.pump » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698