cc/thread_task.h - Issue 11344004: Remove WebKit::Platform dependencies from cc

Side by Side Diff: cc/thread_task.h

Issue 11344004: Remove WebKit::Platform dependencies from cc (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: fix webkit_compositor_bindings_unittests Created 8 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
1 // Copyright 2011 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #ifndef CCThreadTask_h

6 #define CCThreadTask_h

7

8 #include "cc/thread.h"

9 #include <wtf/PassOwnPtr.h>

10

11 namespace cc {

12

13 template<typename T>

14 class ThreadTask0 : public Thread::Task {

15 public:

16 typedef void (T::*Method)();

17 typedef ThreadTask0<T> ThreadTaskImpl;

18

19 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method)

20 {

21 return adoptPtr(new ThreadTaskImpl(instance, method));

22 }

23

24 private:

25 ThreadTask0(T* instance, Method method)

26 : Thread::Task(instance)

27 , m_method(method)

28 {

29 }

30

31 virtual void performTask() OVERRIDE

32 {

33 (static_cast<T>(instance()).*m_method)();

34 }

35

36 private:

37 Method m_method;

38 };

39

40 template<typename T, typename P1, typename MP1>

41 class ThreadTask1 : public Thread::Task {

42 public:

43 typedef void (T::*Method)(MP1);

44 typedef ThreadTask1<T, P1, MP1> ThreadTaskImpl;

45

46 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method, P1 para meter1)

47 {

48 return adoptPtr(new ThreadTaskImpl(instance, method, parameter1));

49 }

50

51 private:

52 ThreadTask1(T* instance, Method method, P1 parameter1)

53 : Thread::Task(instance)

54 , m_method(method)

55 , m_parameter1(parameter1)

56 {

57 }

58

59 virtual void performTask() OVERRIDE

60 {

61 (static_cast<T>(instance()).*m_method)(m_parameter1);

62 }

63

64 private:

65 Method m_method;

66 P1 m_parameter1;

67 };

68

69 template<typename T, typename P1, typename MP1, typename P2, typename MP2>

70 class ThreadTask2 : public Thread::Task {

71 public:

72 typedef void (T::*Method)(MP1, MP2);

73 typedef ThreadTask2<T, P1, MP1, P2, MP2> ThreadTaskImpl;

74

75 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method, P1 para meter1, P2 parameter2)

76 {

77 return adoptPtr(new ThreadTaskImpl(instance, method, parameter1, paramet er2));

78 }

79

80 private:

81 ThreadTask2(T* instance, Method method, P1 parameter1, P2 parameter2)

82 : Thread::Task(instance)

83 , m_method(method)

84 , m_parameter1(parameter1)

85 , m_parameter2(parameter2)

86 {

87 }

88

89 virtual void performTask() OVERRIDE

90 {

91 (static_cast<T>(instance()).*m_method)(m_parameter1, m_parameter2);

92 }

93

94 private:

95 Method m_method;

96 P1 m_parameter1;

97 P2 m_parameter2;

98 };

99

100 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3>

101 class ThreadTask3 : public Thread::Task {

102 public:

103 typedef void (T::*Method)(MP1, MP2, MP3);

104 typedef ThreadTask3<T, P1, MP1, P2, MP2, P3, MP3> ThreadTaskImpl;

105

106 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method, P1 para meter1, P2 parameter2, P3 parameter3)

107 {

108 return adoptPtr(new ThreadTaskImpl(instance, method, parameter1, paramet er2, parameter3));

109 }

110

111 private:

112 ThreadTask3(T* instance, Method method, P1 parameter1, P2 parameter2, P3 par ameter3)

113 : Thread::Task(instance)

114 , m_method(method)

115 , m_parameter1(parameter1)

116 , m_parameter2(parameter2)

117 , m_parameter3(parameter3)

118 {

119 }

120

121 virtual void performTask() OVERRIDE

122 {

123 (static_cast<T>(instance()).*m_method)(m_parameter1, m_parameter2, m_p arameter3);

124 }

125

126 private:

127 Method m_method;

128 P1 m_parameter1;

129 P2 m_parameter2;

130 P3 m_parameter3;

131 };

132

133

134 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3, typename P4, typename MP4>

135 class ThreadTask4 : public Thread::Task {

136 public:

137 typedef void (T::*Method)(MP1, MP2, MP3, MP4);

138 typedef ThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4> ThreadTaskImpl;

139

140 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method, P1 para meter1, P2 parameter2, P3 parameter3, P4 parameter4)

141 {

142 return adoptPtr(new ThreadTaskImpl(instance, method, parameter1, paramet er2, parameter3, parameter4));

143 }

144

145 private:

146 ThreadTask4(T* instance, Method method, P1 parameter1, P2 parameter2, P3 par ameter3, P4 parameter4)

147 : Thread::Task(instance)

148 , m_method(method)

149 , m_parameter1(parameter1)

150 , m_parameter2(parameter2)

151 , m_parameter3(parameter3)

152 , m_parameter4(parameter4)

153 {

154 }

155

156 virtual void performTask() OVERRIDE

157 {

158 (static_cast<T>(instance()).*m_method)(m_parameter1, m_parameter2, m_p arameter3, m_parameter4);

159 }

160

161 private:

162 Method m_method;

163 P1 m_parameter1;

164 P2 m_parameter2;

165 P3 m_parameter3;

166 P4 m_parameter4;

167 };

168

169 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>

170 class ThreadTask5 : public Thread::Task {

171 public:

172 typedef void (T::*Method)(MP1, MP2, MP3, MP4, MP5);

173 typedef ThreadTask5<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5> ThreadTa skImpl;

174

175 static PassOwnPtr<ThreadTaskImpl> create(T* instance, Method method, P1 para meter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5)

176 {

177 return adoptPtr(new ThreadTaskImpl(instance, method, parameter1, paramet er2, parameter3, parameter4, parameter5));

178 }

179

180 private:

181 ThreadTask5(T* instance, Method method, P1 parameter1, P2 parameter2, P3 par ameter3, P4 parameter4, P5 parameter5)

182 : Thread::Task(instance)

183 , m_method(method)

184 , m_parameter1(parameter1)

185 , m_parameter2(parameter2)

186 , m_parameter3(parameter3)

187 , m_parameter4(parameter4)

188 , m_parameter5(parameter5)

189 {

190 }

191

192 virtual void performTask() OVERRIDE

193 {

194 (static_cast<T>(instance()).*m_method)(m_parameter1, m_parameter2, m_p arameter3, m_parameter4, m_parameter5);

195 }

196

197 private:

198 Method m_method;

199 P1 m_parameter1;

200 P2 m_parameter2;

201 P3 m_parameter3;

202 P4 m_parameter4;

203 P5 m_parameter5;

204 };

205

206 template<typename T>

207 PassOwnPtr<Thread::Task> createThreadTask(

208 T* const callee,

209 void (T::*method)());

210

211 template<typename T>

212 PassOwnPtr<Thread::Task> createThreadTask(

213 T* const callee,

214 void (T::*method)())

215 {

216 return ThreadTask0<T>::create(

217 callee,

218 method);

219 }

220

221 template<typename T, typename P1, typename MP1>

222 PassOwnPtr<Thread::Task> createThreadTask(

223 T* const callee,

224 void (T::*method)(MP1),

225 const P1& parameter1)

226 {

227 return ThreadTask1<T, P1, MP1>::create(

228 callee,

229 method,

230 parameter1);

231 }

232

233 template<typename T, typename P1, typename MP1, typename P2, typename MP2>

234 PassOwnPtr<Thread::Task> createThreadTask(

235 T* const callee,

236 void (T::*method)(MP1, MP2),

237 const P1& parameter1,

238 const P2& parameter2)

239 {

240 return ThreadTask2<T, P1, MP1, P2, MP2>::create(

241 callee,

242 method,

243 parameter1,

244 parameter2);

245 }

246

247 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3>

248 PassOwnPtr<Thread::Task> createThreadTask(

249 T* const callee,

250 void (T::*method)(MP1, MP2, MP3),

251 const P1& parameter1,

252 const P2& parameter2,

253 const P3& parameter3)

254 {

255 return ThreadTask3<T, P1, MP1, P2, MP2, P3, MP3>::create(

256 callee,

257 method,

258 parameter1,

259 parameter2,

260 parameter3);

261 }

262

263 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3, typename P4, typename MP4>

264 PassOwnPtr<Thread::Task> createThreadTask(

265 T* const callee,

266 void (T::*method)(MP1, MP2, MP3, MP4),

267 const P1& parameter1,

268 const P2& parameter2,

269 const P3& parameter3,

270 const P4& parameter4)

271 {

272 return ThreadTask4<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4>::create(

273 callee,

274 method,

275 parameter1,

276 parameter2,

277 parameter3,

278 parameter4);

279

280 }

281

282 template<typename T, typename P1, typename MP1, typename P2, typename MP2, typen ame P3, typename MP3, typename P4, typename MP4, typename P5, typename MP5>

283 PassOwnPtr<Thread::Task> createThreadTask(

284 T* const callee,

285 void (T::*method)(MP1, MP2, MP3, MP4, MP5),

286 const P1& parameter1,

287 const P2& parameter2,

288 const P3& parameter3,

289 const P4& parameter4,

290 const P5& parameter5)

291 {

292 return ThreadTask5<T, P1, MP1, P2, MP2, P3, MP3, P4, MP4, P5, MP5>::create(

293 callee,

294 method,

295 parameter1,

296 parameter2,

297 parameter3,

298 parameter4,

299 parameter5);

300

301 }

302

303 } // namespace cc

304

305 #endif // CCThreadTask_h

OLD	NEW

« no previous file with comments | « cc/thread_proxy.cc ('k') | cc/thread_task_unittest.cc » ('j') | no next file with comments »