cc: Use correct message loop proxy in BlockingTaskRunner

cc/trees/blocking_task_runner.cc

Index: cc/trees/blocking_task_runner.cc
diff --git a/cc/trees/blocking_task_runner.cc b/cc/trees/blocking_task_runner.cc
index 2586375436d3684e1910db3ee5dee918b53a6107..9a40a5a4c4830329719c655fd37e522291c86f77 100644
--- a/cc/trees/blocking_task_runner.cc
+++ b/cc/trees/blocking_task_runner.cc
@@ -6,62 +6,29 @@
 
 #include <utility>
 
+#include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/singleton.h"
 #include "base/message_loop/message_loop_proxy.h"
 
 namespace cc {
 
-struct TaskRunnerPairs {
-  static TaskRunnerPairs* GetInstance() {
-    return Singleton<TaskRunnerPairs>::get();
-  }
-
-  base::Lock lock;
-  std::vector<scoped_refptr<BlockingTaskRunner> > runners;
-
- private:
-  friend struct DefaultSingletonTraits<TaskRunnerPairs>;
-};
-
 // static
-scoped_refptr<BlockingTaskRunner> BlockingTaskRunner::current() {
-  TaskRunnerPairs* task_runners = TaskRunnerPairs::GetInstance();
-  base::PlatformThreadId thread_id = base::PlatformThread::CurrentId();
-
-  base::AutoLock lock(task_runners->lock);
-
-  scoped_refptr<BlockingTaskRunner> current_task_runner;
-
-  for (size_t i = 0; i < task_runners->runners.size(); ++i) {
-    if (task_runners->runners[i]->thread_id_ == thread_id) {
-      current_task_runner = task_runners->runners[i];
-    } else if (task_runners->runners[i]->HasOneRef()) {
-      task_runners->runners.erase(task_runners->runners.begin() + i);
-      i--;
-    }
-  }
-
-  if (current_task_runner.get())
-    return current_task_runner;
-
+scoped_refptr<BlockingTaskRunner> BlockingTaskRunner::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   scoped_refptr<BlockingTaskRunner> runner =
-      new BlockingTaskRunner(base::MessageLoopProxy::current());
-  task_runners->runners.push_back(runner);
+      new BlockingTaskRunner(task_runner);
   return runner;
 }
 
 BlockingTaskRunner::BlockingTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : thread_id_(base::PlatformThread::CurrentId()),
-      task_runner_(task_runner),
-      capture_(0) {
+    : task_runner_(task_runner), capture_(0) {
 }
 
 BlockingTaskRunner::~BlockingTaskRunner() {}
 
 bool BlockingTaskRunner::BelongsToCurrentThread() {
-  return base::PlatformThread::CurrentId() == thread_id_;
+  return task_runner_ ? task_runner_->BelongsToCurrentThread() : true;

[danakj, 2014/08/28 17:10:46]

The LayerTreeHostNoMessageLoopTest test passes a NULL task runner which is why
this was using thread_id_ instead of the task runner to do this check. Does this
not crash for that test? If not, can you explain why it wouldn't crash
elsewhere?

[Sami, 2014/08/28 18:21:16]

It doesn't crash because of the NULL check, which I guess is cheating a bit :)
However if a BlockingTaskRunner has no SingleThreadTaskRunner, you could say it
doesn't belong to any specific thread.  I considered keeping the thread_id_
around, but I didn't see why we'd need to restrict which thread
BlockingTaskRunner gets created on so I took it out.

The NULL check is only needed for LayerTreeHostNoMessageLoopTest all others
either have a valid message loop or never end up running uncaptured tasks.

[Sami, 2014/08/28 18:24:41]

Whoops, I meant any tasks -- captured or not.

 }
 
 bool BlockingTaskRunner::PostTask(const tracked_objects::Location& from_here,
@@ -94,8 +61,9 @@ void BlockingTaskRunner::SetCapture(bool capture) {
     tasks[i].Run();
 }
 
-BlockingTaskRunner::CapturePostTasks::CapturePostTasks()
-    : blocking_runner_(BlockingTaskRunner::current()) {
+BlockingTaskRunner::CapturePostTasks::CapturePostTasks(
+    scoped_refptr<BlockingTaskRunner> blocking_runner)
+    : blocking_runner_(blocking_runner) {
   blocking_runner_->SetCapture(true);
 }