scheduler: Always create a real scheduler in unit tests

components/scheduler/renderer/lazy_scheduler_message_loop_delegate.cc

+// 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.
+
+#include "components/scheduler/renderer/lazy_scheduler_message_loop_delegate.h"
+
+namespace scheduler {
+
+// static
+scoped_refptr<LazySchedulerMessageLoopDelegate>
+LazySchedulerMessageLoopDelegate::Create() {
+  return make_scoped_refptr(new LazySchedulerMessageLoopDelegate());
+}
+
+LazySchedulerMessageLoopDelegate::LazySchedulerMessageLoopDelegate()
+    : thread_id_(base::PlatformThread::CurrentId()) {
+}
+
+LazySchedulerMessageLoopDelegate::~LazySchedulerMessageLoopDelegate() {
+}
+
+base::MessageLoop* LazySchedulerMessageLoopDelegate::EnsureMessageLoop() const {
+  base::MessageLoop* message_loop = base::MessageLoop::current();
+  DCHECK(message_loop);
+  for (auto& observer : pending_observers_) {
+    message_loop->AddTaskObserver(observer);
+  }
+  pending_observers_.clear();
+  return message_loop;
+}
+
+bool LazySchedulerMessageLoopDelegate::HasMessageLoop() const {
+  return base::MessageLoop::current() != nullptr;
+}
+
+bool LazySchedulerMessageLoopDelegate::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return EnsureMessageLoop()->task_runner()->PostDelayedTask(from_here, task,
+                                                             delay);
+}
+
+bool LazySchedulerMessageLoopDelegate::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return EnsureMessageLoop()->task_runner()->PostNonNestableDelayedTask(
+      from_here, task, delay);
+}
+
+bool LazySchedulerMessageLoopDelegate::RunsTasksOnCurrentThread() const {
+  return thread_id_ == base::PlatformThread::CurrentId();
+}
+
+bool LazySchedulerMessageLoopDelegate::IsNested() const {
+  return EnsureMessageLoop()->IsNested();
+}
+
+void LazySchedulerMessageLoopDelegate::AddTaskObserver(
+    base::MessageLoop::TaskObserver* task_observer) {
+  if (!HasMessageLoop()) {
+    pending_observers_.insert(task_observer);
+    return;
+  }
+  EnsureMessageLoop()->AddTaskObserver(task_observer);
+}
+
+void LazySchedulerMessageLoopDelegate::RemoveTaskObserver(
+    base::MessageLoop::TaskObserver* task_observer) {
+  if (!HasMessageLoop()) {
+    pending_observers_.erase(task_observer);
+    return;
+  }
+  EnsureMessageLoop()->RemoveTaskObserver(task_observer);
+}
+
+}  // namespace scheduler