OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
dcheng
2015/05/26 20:35:44
In the future, I would recommend trying to split u
| |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 // | |
5 // Test file for the MessageLoop refactoring clang tool. | |
6 | |
7 // Test scaffolding | |
8 // ------------------------------------------------------------ | |
9 | |
10 template <class T> | |
11 class scoped_refptr { | |
12 public: | |
13 T* operator->(); | |
14 T* get(); | |
15 }; | |
16 | |
17 namespace base { | |
18 | |
19 class SingleThreadTaskRunner { | |
20 public: | |
21 void PostTask(); | |
22 void PostDelayedTask(); | |
23 void PostNonNestableTask(); | |
24 void PostNonNestableDelayedTask(); | |
25 }; | |
26 | |
27 class MessageLoopProxy : public SingleThreadTaskRunner { | |
28 public: | |
29 static scoped_refptr<MessageLoopProxy> current(); | |
30 }; | |
31 | |
32 class MessageLoop { | |
33 public: | |
34 void PostTask(); | |
35 void PostDelayedTask(); | |
36 void PostNonNestableTask(); | |
37 void PostNonNestableDelayedTask(); | |
38 | |
39 scoped_refptr<SingleThreadTaskRunner> task_runner(); | |
40 scoped_refptr<MessageLoopProxy> message_loop_proxy(); | |
41 | |
42 static MessageLoop* current(); | |
43 }; | |
44 | |
45 class Thread { | |
46 public: | |
47 scoped_refptr<SingleThreadTaskRunner> task_runner(); | |
48 scoped_refptr<MessageLoopProxy> message_loop_proxy(); | |
49 }; | |
50 | |
51 class ThreadTaskRunnerHandle { | |
52 public: | |
53 static scoped_refptr<SingleThreadTaskRunner> Get(); | |
54 }; | |
55 | |
56 } // namespace base | |
57 | |
58 // Test cases | |
59 // ------------------------------------------------------------ | |
60 | |
61 void TestPostTask() { | |
62 base::MessageLoop loop; | |
63 | |
64 loop.PostTask(); | |
65 (&loop)->PostDelayedTask(); | |
66 loop.PostNonNestableTask(); | |
67 (&loop)->PostNonNestableDelayedTask(); | |
68 } | |
69 | |
70 void TestMessageLoopProxyGetter() { | |
71 base::MessageLoop loop; | |
72 | |
73 loop.message_loop_proxy()->PostTask(); | |
74 } | |
75 | |
76 void TestThreadMessageLoopProxyGetter() { | |
77 base::Thread thread; | |
78 | |
79 thread.message_loop_proxy()->PostTask(); | |
80 } | |
81 | |
82 void TestMessageLoopProxyCurrent() { | |
83 base::MessageLoopProxy::current()->PostTask(); | |
84 } | |
85 | |
86 void TestMessageLoopProxyPointer() { | |
87 base::MessageLoopProxy* proxy; | |
88 proxy->PostTask(); | |
89 } | |
90 | |
91 void TestMessageLoopProxyRefPtr1() { | |
92 scoped_refptr<base::MessageLoopProxy> message_loop_proxy; | |
93 message_loop_proxy->PostTask(); | |
94 } | |
95 | |
96 void TestMessageLoopProxyRefPtr2() { | |
97 scoped_refptr<base::MessageLoopProxy> loop_proxy; | |
98 loop_proxy->PostTask(); | |
99 } | |
100 | |
101 void TestMessageLoopProxyRefPtr3() { | |
102 scoped_refptr<base::MessageLoopProxy> proxy; | |
103 proxy->PostTask(); | |
104 } | |
105 | |
106 void Function1(base::MessageLoopProxy* proxy); | |
107 void Function2(scoped_refptr<base::MessageLoopProxy> proxy); | |
108 | |
109 class TestClass1 { | |
110 public: | |
111 TestClass1() : message_loop_proxy_() {} | |
112 | |
113 void Post() { message_loop_proxy_->PostTask(); } | |
114 | |
115 void Method1(base::MessageLoopProxy* proxy); | |
116 void Method2(scoped_refptr<base::MessageLoopProxy> proxy) {} | |
117 | |
118 void PassAsParam() { Method2(message_loop_proxy_); } | |
119 | |
120 scoped_refptr<base::MessageLoopProxy> message_loop_proxy_; | |
121 }; | |
122 | |
123 class TestClass2 { | |
124 public: | |
125 TestClass2() : message_loop_proxy_() {} | |
126 | |
127 void Post() { message_loop_proxy_->PostTask(); } | |
128 | |
129 base::MessageLoopProxy* Getter() { | |
130 return message_loop_proxy_; | |
131 } | |
132 | |
133 base::MessageLoopProxy* message_loop_proxy_; | |
134 }; | |
135 | |
136 class BaseClass { | |
137 public: | |
138 BaseClass(scoped_refptr<base::MessageLoopProxy> proxy) : proxy_(proxy) {} | |
139 | |
140 private: | |
141 scoped_refptr<base::MessageLoopProxy> proxy_; | |
142 }; | |
143 | |
144 class TestClass3 : public BaseClass { | |
145 public: | |
146 TestClass3(scoped_refptr<base::MessageLoopProxy> proxy) : BaseClass(proxy) {} | |
147 }; | |
148 | |
149 class TestClass4 { | |
150 public: | |
151 TestClass4() : proxy_(base::MessageLoopProxy::current()) {} | |
152 | |
153 scoped_refptr<base::MessageLoopProxy> Getter() { | |
154 return proxy_; | |
155 } | |
156 | |
157 void ProxyRef(const scoped_refptr<base::MessageLoopProxy>& proxy) { | |
158 proxy_ = proxy; | |
159 } | |
160 | |
161 private: | |
162 scoped_refptr<base::MessageLoopProxy> proxy_; | |
163 }; | |
164 | |
165 namespace base { | |
166 | |
167 void TestMessageLoopProxyRefPtrInBase() { | |
168 scoped_refptr<MessageLoopProxy> proxy; | |
169 } | |
170 | |
171 } // namespace base | |
OLD | NEW |