cc: Use correct message loop proxy in BlockingTaskRunner

cc/trees/blocking_task_runner.cc

 // Copyright 2013 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.
 
 #include "cc/trees/blocking_task_runner.h"
 
 #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,
                                   const base::Closure& task) {
   base::AutoLock lock(lock_);
   DCHECK(task_runner_.get() || capture_);
   if (!capture_)
     return task_runner_->PostTask(from_here, task);
   captured_tasks_.push_back(task);
   return true;
@@ skipping 12 matching lines @@
     if (capture_)
       return;
 
     // We're done capturing, so grab all the captured tasks and run them.
     tasks.swap(captured_tasks_);
   }
   for (size_t i = 0; i < tasks.size(); ++i)
     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);
 }
 
 BlockingTaskRunner::CapturePostTasks::~CapturePostTasks() {
   blocking_runner_->SetCapture(false);
 }
 
 }  // namespace cc