clang: Add a tool for MessageLoop refactoring

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

Index: tools/clang/refactor_message_loop/tests/test-expected.cc
diff --git a/tools/clang/refactor_message_loop/tests/test-expected.cc b/tools/clang/refactor_message_loop/tests/test-expected.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f2bf0c8ab76b9dbd45d4faaa6ec68dfb8ba1f227
--- /dev/null
+++ b/tools/clang/refactor_message_loop/tests/test-expected.cc
@@ -0,0 +1,171 @@
+// Copyright 2015 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.
+//
+// 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.task_runner()->PostTask();
+  (&loop)->task_runner()->PostDelayedTask();
+  loop.task_runner()->PostNonNestableTask();
+  (&loop)->task_runner()->PostNonNestableDelayedTask();
+}
+
+void TestMessageLoopProxyGetter() {
+  base::MessageLoop loop;
+
+  loop.task_runner()->PostTask();
+}
+
+void TestThreadMessageLoopProxyGetter() {
+  base::Thread thread;
+
+  thread.task_runner()->PostTask();
+}
+
+void TestMessageLoopProxyCurrent() {
+  base::ThreadTaskRunnerHandle::Get()->PostTask();
+}
+
+void TestMessageLoopProxyPointer() {
+  base::SingleThreadTaskRunner* task_runner;
+  task_runner->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr1() {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  task_runner->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr2() {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  task_runner->PostTask();
+}
+
+void TestMessageLoopProxyRefPtr3() {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  task_runner->PostTask();
+}
+
+void Function1(base::SingleThreadTaskRunner* task_runner);
+void Function2(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+class TestClass1 {
+ public:
+  TestClass1() : task_runner_() {}
+
+  void Post() { task_runner_->PostTask(); }
+
+  void Method1(base::SingleThreadTaskRunner* task_runner);
+  void Method2(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {}
+
+  void PassAsParam() { Method2(task_runner_); }
+
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+};
+
+class TestClass2 {
+ public:
+  TestClass2() : task_runner_() {}
+
+  void Post() { task_runner_->PostTask(); }
+
+  base::SingleThreadTaskRunner* Getter() {
+    return task_runner_;
+  }
+
+  base::SingleThreadTaskRunner* task_runner_;
+};
+
+class BaseClass {
+ public:
+  BaseClass(scoped_refptr<base::SingleThreadTaskRunner> task_runner) : task_runner_(task_runner) {}
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+};
+
+class TestClass3 : public BaseClass {
+ public:
+  TestClass3(scoped_refptr<base::SingleThreadTaskRunner> task_runner) : BaseClass(task_runner) {}
+};
+
+class TestClass4 {
+ public:
+  TestClass4() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+
+  scoped_refptr<base::SingleThreadTaskRunner> Getter() {
+    return task_runner_;
+  }
+
+  void ProxyRef(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+    task_runner_ = task_runner;
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+};
+
+namespace base {
+
+void TestMessageLoopProxyRefPtrInBase() {
+  scoped_refptr<SingleThreadTaskRunner> task_runner;
+}
+
+}  // namespace base