cc: Split Proxy to eliminate unnecessary dependencies on the impl side

cc/trees/thread_verifier.h

Index: cc/trees/thread_verifier.h
diff --git a/cc/trees/thread_verifier.h b/cc/trees/thread_verifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..3af16751f802c988626dd887397611e6bdca9061
--- /dev/null
+++ b/cc/trees/thread_verifier.h
@@ -0,0 +1,104 @@
+// 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.
+
+#ifndef CC_TREES_THREAD_VERIFIER_H_
+#define CC_TREES_THREAD_VERIFIER_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/threading/platform_thread.h"
+#include "base/time/time.h"
+#include "base/values.h"
+#include "cc/base/cc_export.h"
+
+namespace base {
+namespace trace_event {
+class TracedValue;
+}
+class SingleThreadTaskRunner;
+}
+
+namespace cc {
+class BlockingTaskRunner;
+
+// Class responsible for controlling access to the main and impl task runners.
+// Useful for assertion checks.
+class CC_EXPORT ThreadVerifier {

[vmpstr, 2015/10/16 18:42:26]

I'd maybe prefer to call this something like TaskRunnerProvider instead, since
it's not so much verifying things as it provides task runners for different
threads. 

[Khushal, 2015/10/17 00:06:30]

Done. That name makes much more sense.

+ public:
+  base::SingleThreadTaskRunner* MainThreadTaskRunner() const;
+  bool HasImplThread() const;
+  base::SingleThreadTaskRunner* ImplThreadTaskRunner() const;
+
+  // Debug hooks.
+  bool IsMainThread() const;
+  bool IsImplThread() const;
+  bool IsMainThreadBlocked() const;
+#if DCHECK_IS_ON()
+  void SetMainThreadBlocked(bool is_main_thread_blocked);
+  void SetCurrentThreadIsImplThread(bool is_impl_thread);
+#endif
+
+  virtual ~ThreadVerifier();
+
+  BlockingTaskRunner* blocking_main_thread_task_runner() const {
+    return blocking_main_thread_task_runner_.get();
+  }
+
+  ThreadVerifier(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+                 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
+
+ protected:
+  friend class DebugScopedSetImplThread;
+  friend class DebugScopedSetMainThread;
+  friend class DebugScopedSetMainThreadBlocked;
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
+  scoped_ptr<BlockingTaskRunner> blocking_main_thread_task_runner_;
+
+#if DCHECK_IS_ON()
+  const base::PlatformThreadId main_thread_id_;
+  bool impl_thread_is_overridden_;
+  bool is_main_thread_blocked_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadVerifier);
+};
+
+#if DCHECK_IS_ON()
+class DebugScopedSetMainThreadBlocked {
+ public:
+  explicit DebugScopedSetMainThreadBlocked(ThreadVerifier* thread_verifier)
+      : thread_verifier_(thread_verifier) {
+    DCHECK(!thread_verifier_->IsMainThreadBlocked());
+    thread_verifier_->SetMainThreadBlocked(true);
+  }
+  ~DebugScopedSetMainThreadBlocked() {
+    DCHECK(thread_verifier_->IsMainThreadBlocked());
+    thread_verifier_->SetMainThreadBlocked(false);
+  }
+
+ private:
+  ThreadVerifier* thread_verifier_;
+  DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked);
+};
+#else
+class DebugScopedSetMainThreadBlocked {
+ public:
+  explicit DebugScopedSetMainThreadBlocked(ThreadVerifier* thread_verifier) {}
+  ~DebugScopedSetMainThreadBlocked() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked);
+};
+#endif
+
+}  // namespace cc
+
+#endif  // CC_TREES_THREAD_VERIFIER_H_