clang: Add a tool for MessageLoop refactoring

tools/clang/refactor_message_loop/tests/test-original.cc

Index: tools/clang/refactor_message_loop/tests/test-original.cc
diff --git a/tools/clang/refactor_message_loop/tests/test-original.cc b/tools/clang/refactor_message_loop/tests/test-original.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4c598b610335e22b3d02f52bfb474da76b4b83bb
--- /dev/null
+++ b/tools/clang/refactor_message_loop/tests/test-original.cc
@@ -0,0 +1,171 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.

[dcheng, 2015/05/26 20:35:44]

In the future, I would recommend trying to split up the tests a bit. I didn't
really look through here, and I just kind of assume it happens to cover all the
interesting cases.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Test file for the MessageLoop refactoring clang tool.
+
+// Test scaffolding
+// ------------------------------------------------------------
+
+template <class T>
+class scoped_refptr {
+ public:
+  T* operator->();
+  T* get();
+};
+
+namespace base {
+
+class SingleThreadTaskRunner {
+ public:
+  void PostTask();
+  void PostDelayedTask();
+  void PostNonNestableTask();
+  void PostNonNestableDelayedTask();
+};
+
+class MessageLoopProxy : public SingleThreadTaskRunner {
+ public:
+  static scoped_refptr<MessageLoopProxy> current();
+};
+
+class MessageLoop {
+ public:
+  void PostTask();
+  void PostDelayedTask();
+  void PostNonNestableTask();
+  void PostNonNestableDelayedTask();
+
+  scoped_refptr<SingleThreadTaskRunner> task_runner();
+  scoped_refptr<MessageLoopProxy> message_loop_proxy();
+
+  static MessageLoop* current();
+};
+
+class Thread {
+ public:
+  scoped_refptr<SingleThreadTaskRunner> task_runner();
+  scoped_refptr<MessageLoopProxy> message_loop_proxy();
+};
+
+class ThreadTaskRunnerHandle {
+ public:
+  static scoped_refptr<SingleThreadTaskRunner> Get();
+};
+
+}  // namespace base
+
+// Test cases
+// ------------------------------------------------------------
+
+void TestPostTask() {
+  base::MessageLoop loop;
+
+  loop.PostTask();
+  (&loop)->PostDelayedTask();
+  loop.PostNonNestableTask();
+  (&loop)->PostNonNestableDelayedTask();
+}
+
+void TestMessageLoopProxyGetter() {
+  base::MessageLoop loop;
+
+  loop.message_loop_proxy()->PostTask();
+}
+
+void TestThreadMessageLoopProxyGetter() {
+  base::Thread thread;
+
+  thread.message_loop_proxy()->PostTask();
+}
+
+void TestMessageLoopProxyCurrent() {
+  base::MessageLoopProxy::current()->PostTask();
+}
+
+void TestMessageLoopProxyPointer() {
+  base::MessageLoopProxy* proxy;
+  proxy->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr1() {
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
+  message_loop_proxy->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr2() {
+  scoped_refptr<base::MessageLoopProxy> loop_proxy;
+  loop_proxy->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr3() {
+  scoped_refptr<base::MessageLoopProxy> proxy;
+  proxy->PostTask();
+}
+
+void Function1(base::MessageLoopProxy* proxy);
+void Function2(scoped_refptr<base::MessageLoopProxy> proxy);
+
+class TestClass1 {
+ public:
+  TestClass1() : message_loop_proxy_() {}
+
+  void Post() { message_loop_proxy_->PostTask(); }
+
+  void Method1(base::MessageLoopProxy* proxy);
+  void Method2(scoped_refptr<base::MessageLoopProxy> proxy) {}
+
+  void PassAsParam() { Method2(message_loop_proxy_); }
+
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+};
+
+class TestClass2 {
+ public:
+  TestClass2() : message_loop_proxy_() {}
+
+  void Post() { message_loop_proxy_->PostTask(); }
+
+  base::MessageLoopProxy* Getter() {
+    return message_loop_proxy_;
+  }
+
+  base::MessageLoopProxy* message_loop_proxy_;
+};
+
+class BaseClass {
+ public:
+  BaseClass(scoped_refptr<base::MessageLoopProxy> proxy) : proxy_(proxy) {}
+
+ private:
+  scoped_refptr<base::MessageLoopProxy> proxy_;
+};
+
+class TestClass3 : public BaseClass {
+ public:
+  TestClass3(scoped_refptr<base::MessageLoopProxy> proxy) : BaseClass(proxy) {}
+};
+
+class TestClass4 {
+ public:
+  TestClass4() : proxy_(base::MessageLoopProxy::current()) {}
+
+  scoped_refptr<base::MessageLoopProxy> Getter() {
+    return proxy_;
+  }
+
+  void ProxyRef(const scoped_refptr<base::MessageLoopProxy>& proxy) {
+    proxy_ = proxy;
+  }
+
+ private:
+  scoped_refptr<base::MessageLoopProxy> proxy_;
+};
+
+namespace base {
+
+void TestMessageLoopProxyRefPtrInBase() {
+  scoped_refptr<MessageLoopProxy> proxy;
+}
+
+}  // namespace base