bind.h revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
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
54namespace base {
55
56template <typename Functor>
57base::Callback<
58    typename internal::BindState<
59        typename internal::FunctorTraits<Functor>::RunnableType,
60        typename internal::FunctorTraits<Functor>::RunType,
61        void()>
62            ::UnboundRunType>
63Bind(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
75template <typename Functor, typename P1>
76base::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>
82Bind(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
121template <typename Functor, typename P1, typename P2>
122base::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>
129Bind(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
172template <typename Functor, typename P1, typename P2, typename P3>
173base::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>
181Bind(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
228template <typename Functor, typename P1, typename P2, typename P3, typename P4>
229base::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>
238Bind(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
289template <typename Functor, typename P1, typename P2, typename P3, typename P4,
290    typename P5>
291base::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>
301Bind(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
357template <typename Functor, typename P1, typename P2, typename P3, typename P4,
358    typename P5, typename P6>
359base::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>
370Bind(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
430template <typename Functor, typename P1, typename P2, typename P3, typename P4,
431    typename P5, typename P6, typename P7>
432base::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>
444Bind(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