1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GOOGLE_APIS_DRIVE_TASK_UTIL_H_
#define GOOGLE_APIS_DRIVE_TASK_UTIL_H_
#include "base/bind.h"
#include "base/message_loop/message_loop_proxy.h"
namespace google_apis {
// Runs the task with the task runner.
void RunTaskWithTaskRunner(scoped_refptr<base::TaskRunner> task_runner,
const base::Closure& task);
namespace internal {
// Implementation of the composed callback, whose signature is |Sig|.
template<typename Sig> struct ComposedCallback;
// ComposedCallback with no argument.
template<>
struct ComposedCallback<void()> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Closure& callback) {
runner.Run(callback);
}
};
// ComposedCallback with one argument.
template<typename T1>
struct ComposedCallback<void(T1)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1)>& callback,
T1 arg1) {
runner.Run(base::Bind(callback, arg1));
}
};
// ComposedCallback with two arguments.
template<typename T1, typename T2>
struct ComposedCallback<void(T1, T2)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, T2)>& callback,
T1 arg1, T2 arg2) {
runner.Run(base::Bind(callback, arg1, arg2));
}
};
// ComposedCallback with two arguments, and the last one is scoped_ptr.
template<typename T1, typename T2, typename D2>
struct ComposedCallback<void(T1, scoped_ptr<T2, D2>)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, scoped_ptr<T2, D2>)>& callback,
T1 arg1, scoped_ptr<T2, D2> arg2) {
runner.Run(base::Bind(callback, arg1, base::Passed(&arg2)));
}
};
// ComposedCallback with three arguments.
template<typename T1, typename T2, typename T3>
struct ComposedCallback<void(T1, T2, T3)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, T2, T3)>& callback,
T1 arg1, T2 arg2, T3 arg3) {
runner.Run(base::Bind(callback, arg1, arg2, arg3));
}
};
// ComposedCallback with three arguments, and the last one is scoped_ptr.
template<typename T1, typename T2, typename T3, typename D3>
struct ComposedCallback<void(T1, T2, scoped_ptr<T3, D3>)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, T2, scoped_ptr<T3, D3>)>& callback,
T1 arg1, T2 arg2, scoped_ptr<T3, D3> arg3) {
runner.Run(base::Bind(callback, arg1, arg2, base::Passed(&arg3)));
}
};
// ComposedCallback with four arguments.
template<typename T1, typename T2, typename T3, typename T4>
struct ComposedCallback<void(T1, T2, T3, T4)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, T2, T3, T4)>& callback,
T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
runner.Run(base::Bind(callback, arg1, arg2, arg3, arg4));
}
};
} // namespace internal
// Returns callback that takes arguments (arg1, arg2, ...), create a closure
// by binding them to |callback|, and runs |runner| with the closure.
// I.e. the returned callback works as follows:
// runner.Run(Bind(callback, arg1, arg2, ...))
template<typename CallbackType>
CallbackType CreateComposedCallback(
const base::Callback<void(const base::Closure&)>& runner,
const CallbackType& callback) {
DCHECK(!runner.is_null());
DCHECK(!callback.is_null());
return base::Bind(
&internal::ComposedCallback<typename CallbackType::RunType>::Run,
runner, callback);
}
// Returns callback which runs the given |callback| on the current thread.
template<typename CallbackType>
CallbackType CreateRelayCallback(const CallbackType& callback) {
return CreateComposedCallback(
base::Bind(&RunTaskWithTaskRunner, base::MessageLoopProxy::current()),
callback);
}
} // namespace google_apis
#endif // GOOGLE_APIS_DRIVE_TASK_UTIL_H_
|
