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>
Bind(Functor functor)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>
Bind(Functor functor,const P1 & p1)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>
Bind(Functor functor,const P1 & p1,const P2 & p2)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>
Bind(Functor functor,const P1 & p1,const P2 & p2,const P3 & p3)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>
Bind(Functor functor,const P1 & p1,const P2 & p2,const P3 & p3,const P4 & p4)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>
Bind(Functor functor,const P1 & p1,const P2 & p2,const P3 & p3,const P4 & p4,const P5 & p5)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>
Bind(Functor functor,const P1 & p1,const P2 & p2,const P3 & p3,const P4 & p4,const P5 & p5,const P6 & p6)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>
Bind(Functor functor,const P1 & p1,const P2 & p2,const P3 & p3,const P4 & p4,const P5 & p5,const P6 & p6,const P7 & p7)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_
518