components/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.h"
   6
   7 namespace scheduler {
   8
   9 // static
  10 scoped_refptr<LazySchedulerMessageLoopDelegateForTests>
  11 LazySchedulerMessageLoopDelegateForTests::Create() {
  12   return make_scoped_refptr(new LazySchedulerMessageLoopDelegateForTests());
  13 }
  14
  15 LazySchedulerMessageLoopDelegateForTests::
  16     LazySchedulerMessageLoopDelegateForTests()
  17     : message_loop_(base::MessageLoop::current()),
  18       thread_id_(base::PlatformThread::CurrentId()) {
  19 }
  20
  21 LazySchedulerMessageLoopDelegateForTests::
  22     ~LazySchedulerMessageLoopDelegateForTests() {
  23 }
  24
  25 base::MessageLoop* LazySchedulerMessageLoopDelegateForTests::EnsureMessageLoop()
  26     const {
  27   if (message_loop_)
  28     return message_loop_;
  29   DCHECK(RunsTasksOnCurrentThread());
  30   message_loop_ = base::MessageLoop::current();
  31   DCHECK(message_loop_);
  32   for (auto& observer : pending_observers_) {
  33     message_loop_->AddTaskObserver(observer);
  34   }
  35   pending_observers_.clear();
  36   return message_loop_;
  37 }
  38
  39 bool LazySchedulerMessageLoopDelegateForTests::HasMessageLoop() const {
  40   return message_loop_ != nullptr;
  41 }
  42
  43 bool LazySchedulerMessageLoopDelegateForTests::PostDelayedTask(
  44     const tracked_objects::Location& from_here,
  45     const base::Closure& task,
  46     base::TimeDelta delay) {
  47   return EnsureMessageLoop()->task_runner()->PostDelayedTask(from_here, task,
  48                                                              delay);
  49 }
  50
  51 bool LazySchedulerMessageLoopDelegateForTests::PostNonNestableDelayedTask(
  52     const tracked_objects::Location& from_here,
  53     const base::Closure& task,
  54     base::TimeDelta delay) {
  55   return EnsureMessageLoop()->task_runner()->PostNonNestableDelayedTask(
  56       from_here, task, delay);
  57 }
  58
  59 bool LazySchedulerMessageLoopDelegateForTests::RunsTasksOnCurrentThread()
  60     const {
  61   return thread_id_ == base::PlatformThread::CurrentId();
  62 }
  63
  64 bool LazySchedulerMessageLoopDelegateForTests::IsNested() const {
  65   return EnsureMessageLoop()->IsNested();
  66 }
  67
  68 void LazySchedulerMessageLoopDelegateForTests::AddTaskObserver(
  69     base::MessageLoop::TaskObserver* task_observer) {
  70   if (!HasMessageLoop()) {
  71     pending_observers_.insert(task_observer);
  72     return;
  73   }
  74   EnsureMessageLoop()->AddTaskObserver(task_observer);
  75 }
  76
  77 void LazySchedulerMessageLoopDelegateForTests::RemoveTaskObserver(
  78     base::MessageLoop::TaskObserver* task_observer) {
  79   if (!HasMessageLoop()) {
  80     pending_observers_.erase(task_observer);
  81     return;
  82   }
  83   EnsureMessageLoop()->RemoveTaskObserver(task_observer);
  84 }
  85
  86 }  // namespace scheduler