The Tor Browser / file comparison
comparison: security/sandbox/chromium/base/bind.h
security/sandbox/chromium/base/bind.h
- branch
- TOR_BUG_9701
- changeset 3
- 141e0f1194b1
equal
deleted
inserted
replaced
| -1:000000000000 | 0:72059266df22 |
|---|---|
| 1 // This file was GENERATED by command: | |
| 2 // pump.py bind.h.pump | |
| 3 // DO NOT EDIT BY HAND!!! | |
| 4 | |
| 5 | |
| 6 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 7 // Use of this source code is governed by a BSD-style license that can be | |
| 8 // found in the LICENSE file. | |
| 9 | |
| 10 #ifndef BASE_BIND_H_ | |
| 11 #define BASE_BIND_H_ | |
| 12 | |
| 13 #include "base/bind_internal.h" | |
| 14 #include "base/callback_internal.h" | |
| 15 | |
| 16 // ----------------------------------------------------------------------------- | |
| 17 // Usage documentation | |
| 18 // ----------------------------------------------------------------------------- | |
| 19 // | |
| 20 // See base/callback.h for documentation. | |
| 21 // | |
| 22 // | |
| 23 // ----------------------------------------------------------------------------- | |
| 24 // Implementation notes | |
| 25 // ----------------------------------------------------------------------------- | |
| 26 // | |
| 27 // If you're reading the implementation, before proceeding further, you should | |
| 28 // read the top comment of base/bind_internal.h for a definition of common | |
| 29 // terms and concepts. | |
| 30 // | |
| 31 // RETURN TYPES | |
| 32 // | |
| 33 // Though Bind()'s result is meant to be stored in a Callback<> type, it | |
| 34 // cannot actually return the exact type without requiring a large amount | |
| 35 // of extra template specializations. The problem is that in order to | |
| 36 // discern the correct specialization of Callback<>, Bind would need to | |
| 37 // unwrap the function signature to determine the signature's arity, and | |
| 38 // whether or not it is a method. | |
| 39 // | |
| 40 // Each unique combination of (arity, function_type, num_prebound) where | |
| 41 // function_type is one of {function, method, const_method} would require | |
| 42 // one specialization. We eventually have to do a similar number of | |
| 43 // specializations anyways in the implementation (see the Invoker<>, | |
| 44 // classes). However, it is avoidable in Bind if we return the result | |
| 45 // via an indirection like we do below. | |
| 46 // | |
| 47 // TODO(ajwong): We might be able to avoid this now, but need to test. | |
| 48 // | |
| 49 // It is possible to move most of the COMPILE_ASSERT asserts into BindState<>, | |
| 50 // but it feels a little nicer to have the asserts here so people do not | |
| 51 // need to crack open bind_internal.h. On the other hand, it makes Bind() | |
| 52 // harder to read. | |
| 53 | |
| 54 namespace base { | |
| 55 | |
| 56 template <typename Functor> | |
| 57 base::Callback< | |
| 58 typename internal::BindState< | |
| 59 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 60 typename internal::FunctorTraits<Functor>::RunType, | |
| 61 void()> | |
| 62 ::UnboundRunType> | |
| 63 Bind(Functor functor) { | |
| 64 // Typedefs for how to store and run the functor. | |
| 65 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 66 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 67 | |
| 68 // Use RunnableType::RunType instead of RunType above because our | |
| 69 // checks should below for bound references need to know what the actual | |
| 70 // functor is going to interpret the argument as. | |
| 71 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 72 BoundFunctorTraits; | |
| 73 | |
| 74 typedef internal::BindState<RunnableType, RunType, void()> BindState; | |
| 75 | |
| 76 | |
| 77 return Callback<typename BindState::UnboundRunType>( | |
| 78 new BindState(internal::MakeRunnable(functor))); | |
| 79 } | |
| 80 | |
| 81 template <typename Functor, typename P1> | |
| 82 base::Callback< | |
| 83 typename internal::BindState< | |
| 84 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 85 typename internal::FunctorTraits<Functor>::RunType, | |
| 86 void(typename internal::CallbackParamTraits<P1>::StorageType)> | |
| 87 ::UnboundRunType> | |
| 88 Bind(Functor functor, const P1& p1) { | |
| 89 // Typedefs for how to store and run the functor. | |
| 90 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 91 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 92 | |
| 93 // Use RunnableType::RunType instead of RunType above because our | |
| 94 // checks should below for bound references need to know what the actual | |
| 95 // functor is going to interpret the argument as. | |
| 96 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 97 BoundFunctorTraits; | |
| 98 | |
| 99 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 100 // parameters are disallowed by the Google style guide. Also, binding a | |
| 101 // non-const reference parameter can make for subtle bugs because the | |
| 102 // invoked function will receive a reference to the stored copy of the | |
| 103 // argument and not the original. | |
| 104 COMPILE_ASSERT( | |
| 105 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ), | |
| 106 do_not_bind_functions_with_nonconst_ref); | |
| 107 | |
| 108 // For methods, we need to be careful for parameter 1. We do not require | |
| 109 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 110 // methods. We also disallow binding of an array as the method's target | |
| 111 // object. | |
| 112 COMPILE_ASSERT( | |
| 113 internal::HasIsMethodTag<RunnableType>::value || | |
| 114 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 115 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 116 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 117 !is_array<P1>::value, | |
| 118 first_bound_argument_to_method_cannot_be_array); | |
| 119 typedef internal::BindState<RunnableType, RunType, | |
| 120 void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState; | |
| 121 | |
| 122 | |
| 123 return Callback<typename BindState::UnboundRunType>( | |
| 124 new BindState(internal::MakeRunnable(functor), p1)); | |
| 125 } | |
| 126 | |
| 127 template <typename Functor, typename P1, typename P2> | |
| 128 base::Callback< | |
| 129 typename internal::BindState< | |
| 130 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 131 typename internal::FunctorTraits<Functor>::RunType, | |
| 132 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 133 typename internal::CallbackParamTraits<P2>::StorageType)> | |
| 134 ::UnboundRunType> | |
| 135 Bind(Functor functor, const P1& p1, const P2& p2) { | |
| 136 // Typedefs for how to store and run the functor. | |
| 137 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 138 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 139 | |
| 140 // Use RunnableType::RunType instead of RunType above because our | |
| 141 // checks should below for bound references need to know what the actual | |
| 142 // functor is going to interpret the argument as. | |
| 143 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 144 BoundFunctorTraits; | |
| 145 | |
| 146 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 147 // parameters are disallowed by the Google style guide. Also, binding a | |
| 148 // non-const reference parameter can make for subtle bugs because the | |
| 149 // invoked function will receive a reference to the stored copy of the | |
| 150 // argument and not the original. | |
| 151 COMPILE_ASSERT( | |
| 152 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 153 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ), | |
| 154 do_not_bind_functions_with_nonconst_ref); | |
| 155 | |
| 156 // For methods, we need to be careful for parameter 1. We do not require | |
| 157 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 158 // methods. We also disallow binding of an array as the method's target | |
| 159 // object. | |
| 160 COMPILE_ASSERT( | |
| 161 internal::HasIsMethodTag<RunnableType>::value || | |
| 162 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 163 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 164 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 165 !is_array<P1>::value, | |
| 166 first_bound_argument_to_method_cannot_be_array); | |
| 167 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 168 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 169 typedef internal::BindState<RunnableType, RunType, | |
| 170 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 171 typename internal::CallbackParamTraits<P2>::StorageType)> BindState; | |
| 172 | |
| 173 | |
| 174 return Callback<typename BindState::UnboundRunType>( | |
| 175 new BindState(internal::MakeRunnable(functor), p1, p2)); | |
| 176 } | |
| 177 | |
| 178 template <typename Functor, typename P1, typename P2, typename P3> | |
| 179 base::Callback< | |
| 180 typename internal::BindState< | |
| 181 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 182 typename internal::FunctorTraits<Functor>::RunType, | |
| 183 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 184 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 185 typename internal::CallbackParamTraits<P3>::StorageType)> | |
| 186 ::UnboundRunType> | |
| 187 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) { | |
| 188 // Typedefs for how to store and run the functor. | |
| 189 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 190 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 191 | |
| 192 // Use RunnableType::RunType instead of RunType above because our | |
| 193 // checks should below for bound references need to know what the actual | |
| 194 // functor is going to interpret the argument as. | |
| 195 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 196 BoundFunctorTraits; | |
| 197 | |
| 198 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 199 // parameters are disallowed by the Google style guide. Also, binding a | |
| 200 // non-const reference parameter can make for subtle bugs because the | |
| 201 // invoked function will receive a reference to the stored copy of the | |
| 202 // argument and not the original. | |
| 203 COMPILE_ASSERT( | |
| 204 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 205 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || | |
| 206 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ), | |
| 207 do_not_bind_functions_with_nonconst_ref); | |
| 208 | |
| 209 // For methods, we need to be careful for parameter 1. We do not require | |
| 210 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 211 // methods. We also disallow binding of an array as the method's target | |
| 212 // object. | |
| 213 COMPILE_ASSERT( | |
| 214 internal::HasIsMethodTag<RunnableType>::value || | |
| 215 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 216 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 217 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 218 !is_array<P1>::value, | |
| 219 first_bound_argument_to_method_cannot_be_array); | |
| 220 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 221 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 222 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, | |
| 223 p3_is_refcounted_type_and_needs_scoped_refptr); | |
| 224 typedef internal::BindState<RunnableType, RunType, | |
| 225 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 226 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 227 typename internal::CallbackParamTraits<P3>::StorageType)> BindState; | |
| 228 | |
| 229 | |
| 230 return Callback<typename BindState::UnboundRunType>( | |
| 231 new BindState(internal::MakeRunnable(functor), p1, p2, p3)); | |
| 232 } | |
| 233 | |
| 234 template <typename Functor, typename P1, typename P2, typename P3, typename P4> | |
| 235 base::Callback< | |
| 236 typename internal::BindState< | |
| 237 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 238 typename internal::FunctorTraits<Functor>::RunType, | |
| 239 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 240 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 241 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 242 typename internal::CallbackParamTraits<P4>::StorageType)> | |
| 243 ::UnboundRunType> | |
| 244 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) { | |
| 245 // Typedefs for how to store and run the functor. | |
| 246 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 247 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 248 | |
| 249 // Use RunnableType::RunType instead of RunType above because our | |
| 250 // checks should below for bound references need to know what the actual | |
| 251 // functor is going to interpret the argument as. | |
| 252 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 253 BoundFunctorTraits; | |
| 254 | |
| 255 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 256 // parameters are disallowed by the Google style guide. Also, binding a | |
| 257 // non-const reference parameter can make for subtle bugs because the | |
| 258 // invoked function will receive a reference to the stored copy of the | |
| 259 // argument and not the original. | |
| 260 COMPILE_ASSERT( | |
| 261 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 262 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || | |
| 263 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || | |
| 264 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ), | |
| 265 do_not_bind_functions_with_nonconst_ref); | |
| 266 | |
| 267 // For methods, we need to be careful for parameter 1. We do not require | |
| 268 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 269 // methods. We also disallow binding of an array as the method's target | |
| 270 // object. | |
| 271 COMPILE_ASSERT( | |
| 272 internal::HasIsMethodTag<RunnableType>::value || | |
| 273 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 274 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 275 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 276 !is_array<P1>::value, | |
| 277 first_bound_argument_to_method_cannot_be_array); | |
| 278 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 279 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 280 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, | |
| 281 p3_is_refcounted_type_and_needs_scoped_refptr); | |
| 282 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, | |
| 283 p4_is_refcounted_type_and_needs_scoped_refptr); | |
| 284 typedef internal::BindState<RunnableType, RunType, | |
| 285 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 286 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 287 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 288 typename internal::CallbackParamTraits<P4>::StorageType)> BindState; | |
| 289 | |
| 290 | |
| 291 return Callback<typename BindState::UnboundRunType>( | |
| 292 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4)); | |
| 293 } | |
| 294 | |
| 295 template <typename Functor, typename P1, typename P2, typename P3, typename P4, | |
| 296 typename P5> | |
| 297 base::Callback< | |
| 298 typename internal::BindState< | |
| 299 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 300 typename internal::FunctorTraits<Functor>::RunType, | |
| 301 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 302 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 303 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 304 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 305 typename internal::CallbackParamTraits<P5>::StorageType)> | |
| 306 ::UnboundRunType> | |
| 307 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, | |
| 308 const P5& p5) { | |
| 309 // Typedefs for how to store and run the functor. | |
| 310 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 311 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 312 | |
| 313 // Use RunnableType::RunType instead of RunType above because our | |
| 314 // checks should below for bound references need to know what the actual | |
| 315 // functor is going to interpret the argument as. | |
| 316 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 317 BoundFunctorTraits; | |
| 318 | |
| 319 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 320 // parameters are disallowed by the Google style guide. Also, binding a | |
| 321 // non-const reference parameter can make for subtle bugs because the | |
| 322 // invoked function will receive a reference to the stored copy of the | |
| 323 // argument and not the original. | |
| 324 COMPILE_ASSERT( | |
| 325 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 326 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || | |
| 327 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || | |
| 328 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || | |
| 329 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ), | |
| 330 do_not_bind_functions_with_nonconst_ref); | |
| 331 | |
| 332 // For methods, we need to be careful for parameter 1. We do not require | |
| 333 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 334 // methods. We also disallow binding of an array as the method's target | |
| 335 // object. | |
| 336 COMPILE_ASSERT( | |
| 337 internal::HasIsMethodTag<RunnableType>::value || | |
| 338 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 339 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 340 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 341 !is_array<P1>::value, | |
| 342 first_bound_argument_to_method_cannot_be_array); | |
| 343 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 344 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 345 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, | |
| 346 p3_is_refcounted_type_and_needs_scoped_refptr); | |
| 347 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, | |
| 348 p4_is_refcounted_type_and_needs_scoped_refptr); | |
| 349 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, | |
| 350 p5_is_refcounted_type_and_needs_scoped_refptr); | |
| 351 typedef internal::BindState<RunnableType, RunType, | |
| 352 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 353 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 354 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 355 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 356 typename internal::CallbackParamTraits<P5>::StorageType)> BindState; | |
| 357 | |
| 358 | |
| 359 return Callback<typename BindState::UnboundRunType>( | |
| 360 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5)); | |
| 361 } | |
| 362 | |
| 363 template <typename Functor, typename P1, typename P2, typename P3, typename P4, | |
| 364 typename P5, typename P6> | |
| 365 base::Callback< | |
| 366 typename internal::BindState< | |
| 367 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 368 typename internal::FunctorTraits<Functor>::RunType, | |
| 369 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 370 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 371 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 372 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 373 typename internal::CallbackParamTraits<P5>::StorageType, | |
| 374 typename internal::CallbackParamTraits<P6>::StorageType)> | |
| 375 ::UnboundRunType> | |
| 376 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, | |
| 377 const P5& p5, const P6& p6) { | |
| 378 // Typedefs for how to store and run the functor. | |
| 379 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 380 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 381 | |
| 382 // Use RunnableType::RunType instead of RunType above because our | |
| 383 // checks should below for bound references need to know what the actual | |
| 384 // functor is going to interpret the argument as. | |
| 385 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 386 BoundFunctorTraits; | |
| 387 | |
| 388 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 389 // parameters are disallowed by the Google style guide. Also, binding a | |
| 390 // non-const reference parameter can make for subtle bugs because the | |
| 391 // invoked function will receive a reference to the stored copy of the | |
| 392 // argument and not the original. | |
| 393 COMPILE_ASSERT( | |
| 394 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 395 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || | |
| 396 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || | |
| 397 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || | |
| 398 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || | |
| 399 is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ), | |
| 400 do_not_bind_functions_with_nonconst_ref); | |
| 401 | |
| 402 // For methods, we need to be careful for parameter 1. We do not require | |
| 403 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 404 // methods. We also disallow binding of an array as the method's target | |
| 405 // object. | |
| 406 COMPILE_ASSERT( | |
| 407 internal::HasIsMethodTag<RunnableType>::value || | |
| 408 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 409 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 410 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 411 !is_array<P1>::value, | |
| 412 first_bound_argument_to_method_cannot_be_array); | |
| 413 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 414 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 415 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, | |
| 416 p3_is_refcounted_type_and_needs_scoped_refptr); | |
| 417 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, | |
| 418 p4_is_refcounted_type_and_needs_scoped_refptr); | |
| 419 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, | |
| 420 p5_is_refcounted_type_and_needs_scoped_refptr); | |
| 421 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value, | |
| 422 p6_is_refcounted_type_and_needs_scoped_refptr); | |
| 423 typedef internal::BindState<RunnableType, RunType, | |
| 424 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 425 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 426 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 427 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 428 typename internal::CallbackParamTraits<P5>::StorageType, | |
| 429 typename internal::CallbackParamTraits<P6>::StorageType)> BindState; | |
| 430 | |
| 431 | |
| 432 return Callback<typename BindState::UnboundRunType>( | |
| 433 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6)); | |
| 434 } | |
| 435 | |
| 436 template <typename Functor, typename P1, typename P2, typename P3, typename P4, | |
| 437 typename P5, typename P6, typename P7> | |
| 438 base::Callback< | |
| 439 typename internal::BindState< | |
| 440 typename internal::FunctorTraits<Functor>::RunnableType, | |
| 441 typename internal::FunctorTraits<Functor>::RunType, | |
| 442 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 443 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 444 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 445 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 446 typename internal::CallbackParamTraits<P5>::StorageType, | |
| 447 typename internal::CallbackParamTraits<P6>::StorageType, | |
| 448 typename internal::CallbackParamTraits<P7>::StorageType)> | |
| 449 ::UnboundRunType> | |
| 450 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, | |
| 451 const P5& p5, const P6& p6, const P7& p7) { | |
| 452 // Typedefs for how to store and run the functor. | |
| 453 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; | |
| 454 typedef typename internal::FunctorTraits<Functor>::RunType RunType; | |
| 455 | |
| 456 // Use RunnableType::RunType instead of RunType above because our | |
| 457 // checks should below for bound references need to know what the actual | |
| 458 // functor is going to interpret the argument as. | |
| 459 typedef internal::FunctionTraits<typename RunnableType::RunType> | |
| 460 BoundFunctorTraits; | |
| 461 | |
| 462 // Do not allow binding a non-const reference parameter. Non-const reference | |
| 463 // parameters are disallowed by the Google style guide. Also, binding a | |
| 464 // non-const reference parameter can make for subtle bugs because the | |
| 465 // invoked function will receive a reference to the stored copy of the | |
| 466 // argument and not the original. | |
| 467 COMPILE_ASSERT( | |
| 468 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || | |
| 469 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || | |
| 470 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || | |
| 471 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || | |
| 472 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || | |
| 473 is_non_const_reference<typename BoundFunctorTraits::A6Type>::value || | |
| 474 is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ), | |
| 475 do_not_bind_functions_with_nonconst_ref); | |
| 476 | |
| 477 // For methods, we need to be careful for parameter 1. We do not require | |
| 478 // a scoped_refptr because BindState<> itself takes care of AddRef() for | |
| 479 // methods. We also disallow binding of an array as the method's target | |
| 480 // object. | |
| 481 COMPILE_ASSERT( | |
| 482 internal::HasIsMethodTag<RunnableType>::value || | |
| 483 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, | |
| 484 p1_is_refcounted_type_and_needs_scoped_refptr); | |
| 485 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || | |
| 486 !is_array<P1>::value, | |
| 487 first_bound_argument_to_method_cannot_be_array); | |
| 488 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, | |
| 489 p2_is_refcounted_type_and_needs_scoped_refptr); | |
| 490 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, | |
| 491 p3_is_refcounted_type_and_needs_scoped_refptr); | |
| 492 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, | |
| 493 p4_is_refcounted_type_and_needs_scoped_refptr); | |
| 494 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, | |
| 495 p5_is_refcounted_type_and_needs_scoped_refptr); | |
| 496 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value, | |
| 497 p6_is_refcounted_type_and_needs_scoped_refptr); | |
| 498 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P7>::value, | |
| 499 p7_is_refcounted_type_and_needs_scoped_refptr); | |
| 500 typedef internal::BindState<RunnableType, RunType, | |
| 501 void(typename internal::CallbackParamTraits<P1>::StorageType, | |
| 502 typename internal::CallbackParamTraits<P2>::StorageType, | |
| 503 typename internal::CallbackParamTraits<P3>::StorageType, | |
| 504 typename internal::CallbackParamTraits<P4>::StorageType, | |
| 505 typename internal::CallbackParamTraits<P5>::StorageType, | |
| 506 typename internal::CallbackParamTraits<P6>::StorageType, | |
| 507 typename internal::CallbackParamTraits<P7>::StorageType)> BindState; | |
| 508 | |
| 509 | |
| 510 return Callback<typename BindState::UnboundRunType>( | |
| 511 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, | |
| 512 p7)); | |
| 513 } | |
| 514 | |
| 515 } // namespace base | |
| 516 | |
| 517 #endif // BASE_BIND_H_ |
