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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// 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 CHROME_BROWSER_GOOGLE_APIS_TASK_UTIL_H_
#define CHROME_BROWSER_GOOGLE_APIS_TASK_UTIL_H_
#include "base/bind.h"
#include "base/message_loop/message_loop_proxy.h"
namespace google_apis {
// Runs task on the thread to which |relay_proxy| belongs.
void RunTaskOnThread(scoped_refptr<base::MessageLoopProxy> relay_proxy,
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));
}
};
// ComposedCallback with four arguments, and the second one is scoped_ptr.
template<typename T1, typename T2, typename D2, typename T3, typename T4>
struct ComposedCallback<void(T1, scoped_ptr<T2, D2>, T3, T4)> {
static void Run(
const base::Callback<void(const base::Closure&)>& runner,
const base::Callback<void(T1, scoped_ptr<T2, D2>, T3, T4)>& callback,
T1 arg1, scoped_ptr<T2, D2> arg2, T3 arg3, T4 arg4) {
runner.Run(base::Bind(callback, arg1, base::Passed(&arg2), arg3, arg4));
}
};
// GetDefaultValue returns a value constructed by the default constructor.
template<typename T> struct DefaultValueCreator {
static T GetDefaultValue() { return T(); }
};
template<typename T> struct DefaultValueCreator<const T&> {
static T GetDefaultValue() { return T(); }
};
// Helper of CreateErrorRunCallback implementation.
// Provides:
// - ResultType; the type of the Callback which should be returned by
// CreateErrorRunCallback.
// - Run(): a static function which takes the original |callback| and |error|,
// and runs the |callback|.Run() with the error code and default values
// for remaining arguments.
template<typename CallbackType> struct CreateErrorRunCallbackHelper;
// CreateErrorRunCallback with two arguments.
template<typename ErrorType, typename P1>
struct CreateErrorRunCallbackHelper<void(ErrorType, P1)> {
typedef base::Callback<void(ErrorType)> ResultType;
static void Run(
const base::Callback<void(ErrorType, P1)>& callback, ErrorType error) {
callback.Run(error, DefaultValueCreator<P1>::GetDefaultValue());
}
};
} // 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(&RunTaskOnThread, base::MessageLoopProxy::current()),
callback);
}
// Returns a callback with the tail parameter bound to its default value.
// In other words, returned_callback.Run(error) runs callback.Run(error, T()).
template<typename CallbackType>
typename internal::CreateErrorRunCallbackHelper<CallbackType>::ResultType
CreateErrorRunCallback(const base::Callback<CallbackType>& callback) {
return base::Bind(
&internal::CreateErrorRunCallbackHelper<CallbackType>::Run, callback);
}
} // namespace google_apis
#endif // CHROME_BROWSER_GOOGLE_APIS_TASK_UTIL_H_
|
