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 typedef internal::BindState<RunnableType, RunType, void()> BindState; 69 70 71 return Callback<typename BindState::UnboundRunType>( 72 new BindState(internal::MakeRunnable(functor))); 73 } 74 75 template <typename Functor, typename P1> 76 base::Callback< 77 typename internal::BindState< 78 typename internal::FunctorTraits<Functor>::RunnableType, 79 typename internal::FunctorTraits<Functor>::RunType, 80 void(typename internal::CallbackParamTraits<P1>::StorageType)> 81 ::UnboundRunType> 82 Bind(Functor functor, const P1& p1) { 83 // Typedefs for how to store and run the functor. 84 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 85 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 86 87 // Use RunnableType::RunType instead of RunType above because our 88 // checks should below for bound references need to know what the actual 89 // functor is going to interpret the argument as. 90 typedef internal::FunctionTraits<typename RunnableType::RunType> 91 BoundFunctorTraits; 92 93 // Do not allow binding a non-const reference parameter. Non-const reference 94 // parameters are disallowed by the Google style guide. Also, binding a 95 // non-const reference parameter can make for subtle bugs because the 96 // invoked function will receive a reference to the stored copy of the 97 // argument and not the original. 98 COMPILE_ASSERT( 99 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ), 100 do_not_bind_functions_with_nonconst_ref); 101 102 // For methods, we need to be careful for parameter 1. We do not require 103 // a scoped_refptr because BindState<> itself takes care of AddRef() for 104 // methods. We also disallow binding of an array as the method's target 105 // object. 106 COMPILE_ASSERT( 107 internal::HasIsMethodTag<RunnableType>::value || 108 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 109 p1_is_refcounted_type_and_needs_scoped_refptr); 110 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 111 !is_array<P1>::value, 112 first_bound_argument_to_method_cannot_be_array); 113 typedef internal::BindState<RunnableType, RunType, 114 void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState; 115 116 117 return Callback<typename BindState::UnboundRunType>( 118 new BindState(internal::MakeRunnable(functor), p1)); 119 } 120 121 template <typename Functor, typename P1, typename P2> 122 base::Callback< 123 typename internal::BindState< 124 typename internal::FunctorTraits<Functor>::RunnableType, 125 typename internal::FunctorTraits<Functor>::RunType, 126 void(typename internal::CallbackParamTraits<P1>::StorageType, 127 typename internal::CallbackParamTraits<P2>::StorageType)> 128 ::UnboundRunType> 129 Bind(Functor functor, const P1& p1, const P2& p2) { 130 // Typedefs for how to store and run the functor. 131 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 132 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 133 134 // Use RunnableType::RunType instead of RunType above because our 135 // checks should below for bound references need to know what the actual 136 // functor is going to interpret the argument as. 137 typedef internal::FunctionTraits<typename RunnableType::RunType> 138 BoundFunctorTraits; 139 140 // Do not allow binding a non-const reference parameter. Non-const reference 141 // parameters are disallowed by the Google style guide. Also, binding a 142 // non-const reference parameter can make for subtle bugs because the 143 // invoked function will receive a reference to the stored copy of the 144 // argument and not the original. 145 COMPILE_ASSERT( 146 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 147 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ), 148 do_not_bind_functions_with_nonconst_ref); 149 150 // For methods, we need to be careful for parameter 1. We do not require 151 // a scoped_refptr because BindState<> itself takes care of AddRef() for 152 // methods. We also disallow binding of an array as the method's target 153 // object. 154 COMPILE_ASSERT( 155 internal::HasIsMethodTag<RunnableType>::value || 156 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 157 p1_is_refcounted_type_and_needs_scoped_refptr); 158 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 159 !is_array<P1>::value, 160 first_bound_argument_to_method_cannot_be_array); 161 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 162 p2_is_refcounted_type_and_needs_scoped_refptr); 163 typedef internal::BindState<RunnableType, RunType, 164 void(typename internal::CallbackParamTraits<P1>::StorageType, 165 typename internal::CallbackParamTraits<P2>::StorageType)> BindState; 166 167 168 return Callback<typename BindState::UnboundRunType>( 169 new BindState(internal::MakeRunnable(functor), p1, p2)); 170 } 171 172 template <typename Functor, typename P1, typename P2, typename P3> 173 base::Callback< 174 typename internal::BindState< 175 typename internal::FunctorTraits<Functor>::RunnableType, 176 typename internal::FunctorTraits<Functor>::RunType, 177 void(typename internal::CallbackParamTraits<P1>::StorageType, 178 typename internal::CallbackParamTraits<P2>::StorageType, 179 typename internal::CallbackParamTraits<P3>::StorageType)> 180 ::UnboundRunType> 181 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) { 182 // Typedefs for how to store and run the functor. 183 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 184 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 185 186 // Use RunnableType::RunType instead of RunType above because our 187 // checks should below for bound references need to know what the actual 188 // functor is going to interpret the argument as. 189 typedef internal::FunctionTraits<typename RunnableType::RunType> 190 BoundFunctorTraits; 191 192 // Do not allow binding a non-const reference parameter. Non-const reference 193 // parameters are disallowed by the Google style guide. Also, binding a 194 // non-const reference parameter can make for subtle bugs because the 195 // invoked function will receive a reference to the stored copy of the 196 // argument and not the original. 197 COMPILE_ASSERT( 198 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 199 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || 200 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ), 201 do_not_bind_functions_with_nonconst_ref); 202 203 // For methods, we need to be careful for parameter 1. We do not require 204 // a scoped_refptr because BindState<> itself takes care of AddRef() for 205 // methods. We also disallow binding of an array as the method's target 206 // object. 207 COMPILE_ASSERT( 208 internal::HasIsMethodTag<RunnableType>::value || 209 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 210 p1_is_refcounted_type_and_needs_scoped_refptr); 211 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 212 !is_array<P1>::value, 213 first_bound_argument_to_method_cannot_be_array); 214 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 215 p2_is_refcounted_type_and_needs_scoped_refptr); 216 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, 217 p3_is_refcounted_type_and_needs_scoped_refptr); 218 typedef internal::BindState<RunnableType, RunType, 219 void(typename internal::CallbackParamTraits<P1>::StorageType, 220 typename internal::CallbackParamTraits<P2>::StorageType, 221 typename internal::CallbackParamTraits<P3>::StorageType)> BindState; 222 223 224 return Callback<typename BindState::UnboundRunType>( 225 new BindState(internal::MakeRunnable(functor), p1, p2, p3)); 226 } 227 228 template <typename Functor, typename P1, typename P2, typename P3, typename P4> 229 base::Callback< 230 typename internal::BindState< 231 typename internal::FunctorTraits<Functor>::RunnableType, 232 typename internal::FunctorTraits<Functor>::RunType, 233 void(typename internal::CallbackParamTraits<P1>::StorageType, 234 typename internal::CallbackParamTraits<P2>::StorageType, 235 typename internal::CallbackParamTraits<P3>::StorageType, 236 typename internal::CallbackParamTraits<P4>::StorageType)> 237 ::UnboundRunType> 238 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) { 239 // Typedefs for how to store and run the functor. 240 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 241 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 242 243 // Use RunnableType::RunType instead of RunType above because our 244 // checks should below for bound references need to know what the actual 245 // functor is going to interpret the argument as. 246 typedef internal::FunctionTraits<typename RunnableType::RunType> 247 BoundFunctorTraits; 248 249 // Do not allow binding a non-const reference parameter. Non-const reference 250 // parameters are disallowed by the Google style guide. Also, binding a 251 // non-const reference parameter can make for subtle bugs because the 252 // invoked function will receive a reference to the stored copy of the 253 // argument and not the original. 254 COMPILE_ASSERT( 255 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 256 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || 257 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || 258 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ), 259 do_not_bind_functions_with_nonconst_ref); 260 261 // For methods, we need to be careful for parameter 1. We do not require 262 // a scoped_refptr because BindState<> itself takes care of AddRef() for 263 // methods. We also disallow binding of an array as the method's target 264 // object. 265 COMPILE_ASSERT( 266 internal::HasIsMethodTag<RunnableType>::value || 267 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 268 p1_is_refcounted_type_and_needs_scoped_refptr); 269 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 270 !is_array<P1>::value, 271 first_bound_argument_to_method_cannot_be_array); 272 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 273 p2_is_refcounted_type_and_needs_scoped_refptr); 274 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, 275 p3_is_refcounted_type_and_needs_scoped_refptr); 276 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, 277 p4_is_refcounted_type_and_needs_scoped_refptr); 278 typedef internal::BindState<RunnableType, RunType, 279 void(typename internal::CallbackParamTraits<P1>::StorageType, 280 typename internal::CallbackParamTraits<P2>::StorageType, 281 typename internal::CallbackParamTraits<P3>::StorageType, 282 typename internal::CallbackParamTraits<P4>::StorageType)> BindState; 283 284 285 return Callback<typename BindState::UnboundRunType>( 286 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4)); 287 } 288 289 template <typename Functor, typename P1, typename P2, typename P3, typename P4, 290 typename P5> 291 base::Callback< 292 typename internal::BindState< 293 typename internal::FunctorTraits<Functor>::RunnableType, 294 typename internal::FunctorTraits<Functor>::RunType, 295 void(typename internal::CallbackParamTraits<P1>::StorageType, 296 typename internal::CallbackParamTraits<P2>::StorageType, 297 typename internal::CallbackParamTraits<P3>::StorageType, 298 typename internal::CallbackParamTraits<P4>::StorageType, 299 typename internal::CallbackParamTraits<P5>::StorageType)> 300 ::UnboundRunType> 301 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, 302 const P5& p5) { 303 // Typedefs for how to store and run the functor. 304 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 305 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 306 307 // Use RunnableType::RunType instead of RunType above because our 308 // checks should below for bound references need to know what the actual 309 // functor is going to interpret the argument as. 310 typedef internal::FunctionTraits<typename RunnableType::RunType> 311 BoundFunctorTraits; 312 313 // Do not allow binding a non-const reference parameter. Non-const reference 314 // parameters are disallowed by the Google style guide. Also, binding a 315 // non-const reference parameter can make for subtle bugs because the 316 // invoked function will receive a reference to the stored copy of the 317 // argument and not the original. 318 COMPILE_ASSERT( 319 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 320 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || 321 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || 322 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || 323 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ), 324 do_not_bind_functions_with_nonconst_ref); 325 326 // For methods, we need to be careful for parameter 1. We do not require 327 // a scoped_refptr because BindState<> itself takes care of AddRef() for 328 // methods. We also disallow binding of an array as the method's target 329 // object. 330 COMPILE_ASSERT( 331 internal::HasIsMethodTag<RunnableType>::value || 332 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 333 p1_is_refcounted_type_and_needs_scoped_refptr); 334 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 335 !is_array<P1>::value, 336 first_bound_argument_to_method_cannot_be_array); 337 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 338 p2_is_refcounted_type_and_needs_scoped_refptr); 339 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, 340 p3_is_refcounted_type_and_needs_scoped_refptr); 341 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, 342 p4_is_refcounted_type_and_needs_scoped_refptr); 343 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, 344 p5_is_refcounted_type_and_needs_scoped_refptr); 345 typedef internal::BindState<RunnableType, RunType, 346 void(typename internal::CallbackParamTraits<P1>::StorageType, 347 typename internal::CallbackParamTraits<P2>::StorageType, 348 typename internal::CallbackParamTraits<P3>::StorageType, 349 typename internal::CallbackParamTraits<P4>::StorageType, 350 typename internal::CallbackParamTraits<P5>::StorageType)> BindState; 351 352 353 return Callback<typename BindState::UnboundRunType>( 354 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5)); 355 } 356 357 template <typename Functor, typename P1, typename P2, typename P3, typename P4, 358 typename P5, typename P6> 359 base::Callback< 360 typename internal::BindState< 361 typename internal::FunctorTraits<Functor>::RunnableType, 362 typename internal::FunctorTraits<Functor>::RunType, 363 void(typename internal::CallbackParamTraits<P1>::StorageType, 364 typename internal::CallbackParamTraits<P2>::StorageType, 365 typename internal::CallbackParamTraits<P3>::StorageType, 366 typename internal::CallbackParamTraits<P4>::StorageType, 367 typename internal::CallbackParamTraits<P5>::StorageType, 368 typename internal::CallbackParamTraits<P6>::StorageType)> 369 ::UnboundRunType> 370 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, 371 const P5& p5, const P6& p6) { 372 // Typedefs for how to store and run the functor. 373 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 374 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 375 376 // Use RunnableType::RunType instead of RunType above because our 377 // checks should below for bound references need to know what the actual 378 // functor is going to interpret the argument as. 379 typedef internal::FunctionTraits<typename RunnableType::RunType> 380 BoundFunctorTraits; 381 382 // Do not allow binding a non-const reference parameter. Non-const reference 383 // parameters are disallowed by the Google style guide. Also, binding a 384 // non-const reference parameter can make for subtle bugs because the 385 // invoked function will receive a reference to the stored copy of the 386 // argument and not the original. 387 COMPILE_ASSERT( 388 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 389 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || 390 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || 391 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || 392 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || 393 is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ), 394 do_not_bind_functions_with_nonconst_ref); 395 396 // For methods, we need to be careful for parameter 1. We do not require 397 // a scoped_refptr because BindState<> itself takes care of AddRef() for 398 // methods. We also disallow binding of an array as the method's target 399 // object. 400 COMPILE_ASSERT( 401 internal::HasIsMethodTag<RunnableType>::value || 402 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 403 p1_is_refcounted_type_and_needs_scoped_refptr); 404 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 405 !is_array<P1>::value, 406 first_bound_argument_to_method_cannot_be_array); 407 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 408 p2_is_refcounted_type_and_needs_scoped_refptr); 409 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, 410 p3_is_refcounted_type_and_needs_scoped_refptr); 411 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, 412 p4_is_refcounted_type_and_needs_scoped_refptr); 413 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, 414 p5_is_refcounted_type_and_needs_scoped_refptr); 415 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value, 416 p6_is_refcounted_type_and_needs_scoped_refptr); 417 typedef internal::BindState<RunnableType, RunType, 418 void(typename internal::CallbackParamTraits<P1>::StorageType, 419 typename internal::CallbackParamTraits<P2>::StorageType, 420 typename internal::CallbackParamTraits<P3>::StorageType, 421 typename internal::CallbackParamTraits<P4>::StorageType, 422 typename internal::CallbackParamTraits<P5>::StorageType, 423 typename internal::CallbackParamTraits<P6>::StorageType)> BindState; 424 425 426 return Callback<typename BindState::UnboundRunType>( 427 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6)); 428 } 429 430 template <typename Functor, typename P1, typename P2, typename P3, typename P4, 431 typename P5, typename P6, typename P7> 432 base::Callback< 433 typename internal::BindState< 434 typename internal::FunctorTraits<Functor>::RunnableType, 435 typename internal::FunctorTraits<Functor>::RunType, 436 void(typename internal::CallbackParamTraits<P1>::StorageType, 437 typename internal::CallbackParamTraits<P2>::StorageType, 438 typename internal::CallbackParamTraits<P3>::StorageType, 439 typename internal::CallbackParamTraits<P4>::StorageType, 440 typename internal::CallbackParamTraits<P5>::StorageType, 441 typename internal::CallbackParamTraits<P6>::StorageType, 442 typename internal::CallbackParamTraits<P7>::StorageType)> 443 ::UnboundRunType> 444 Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, 445 const P5& p5, const P6& p6, const P7& p7) { 446 // Typedefs for how to store and run the functor. 447 typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType; 448 typedef typename internal::FunctorTraits<Functor>::RunType RunType; 449 450 // Use RunnableType::RunType instead of RunType above because our 451 // checks should below for bound references need to know what the actual 452 // functor is going to interpret the argument as. 453 typedef internal::FunctionTraits<typename RunnableType::RunType> 454 BoundFunctorTraits; 455 456 // Do not allow binding a non-const reference parameter. Non-const reference 457 // parameters are disallowed by the Google style guide. Also, binding a 458 // non-const reference parameter can make for subtle bugs because the 459 // invoked function will receive a reference to the stored copy of the 460 // argument and not the original. 461 COMPILE_ASSERT( 462 !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || 463 is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || 464 is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || 465 is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || 466 is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || 467 is_non_const_reference<typename BoundFunctorTraits::A6Type>::value || 468 is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ), 469 do_not_bind_functions_with_nonconst_ref); 470 471 // For methods, we need to be careful for parameter 1. We do not require 472 // a scoped_refptr because BindState<> itself takes care of AddRef() for 473 // methods. We also disallow binding of an array as the method's target 474 // object. 475 COMPILE_ASSERT( 476 internal::HasIsMethodTag<RunnableType>::value || 477 !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, 478 p1_is_refcounted_type_and_needs_scoped_refptr); 479 COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value || 480 !is_array<P1>::value, 481 first_bound_argument_to_method_cannot_be_array); 482 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, 483 p2_is_refcounted_type_and_needs_scoped_refptr); 484 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, 485 p3_is_refcounted_type_and_needs_scoped_refptr); 486 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, 487 p4_is_refcounted_type_and_needs_scoped_refptr); 488 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, 489 p5_is_refcounted_type_and_needs_scoped_refptr); 490 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value, 491 p6_is_refcounted_type_and_needs_scoped_refptr); 492 COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P7>::value, 493 p7_is_refcounted_type_and_needs_scoped_refptr); 494 typedef internal::BindState<RunnableType, RunType, 495 void(typename internal::CallbackParamTraits<P1>::StorageType, 496 typename internal::CallbackParamTraits<P2>::StorageType, 497 typename internal::CallbackParamTraits<P3>::StorageType, 498 typename internal::CallbackParamTraits<P4>::StorageType, 499 typename internal::CallbackParamTraits<P5>::StorageType, 500 typename internal::CallbackParamTraits<P6>::StorageType, 501 typename internal::CallbackParamTraits<P7>::StorageType)> BindState; 502 503 504 return Callback<typename BindState::UnboundRunType>( 505 new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, 506 p7)); 507 } 508 509 } // namespace base 510 511 #endif // BASE_BIND_H_ 512
