← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/bind.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/bind.h
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_