extensions/common/one_shot_event.cc

   1 // Copyright 2013 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 "extensions/common/one_shot_event.h"
   6
   7 #include "base/callback.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/location.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "base/task_runner.h"
  12 #include "base/time/time.h"
  13
  14 using base::TaskRunner;
  15
  16 namespace extensions {
  17
  18 struct OneShotEvent::TaskInfo {
  19   TaskInfo() {}
  20   TaskInfo(const tracked_objects::Location& from_here,
  21            const scoped_refptr<TaskRunner>& runner,
  22            const base::Closure& task,
  23            const base::TimeDelta& delay)
  24       : from_here(from_here), runner(runner), task(task), delay(delay) {
  25     CHECK(runner.get());  // Detect mistakes with a decent stack frame.
  26   }
  27   tracked_objects::Location from_here;
  28   scoped_refptr<TaskRunner> runner;
  29   base::Closure task;
  30   base::TimeDelta delay;
  31 };
  32
  33 OneShotEvent::OneShotEvent() : signaled_(false) {
  34   // It's acceptable to construct the OneShotEvent on one thread, but
  35   // immediately move it to another thread.
  36   thread_checker_.DetachFromThread();
  37 }
  38 OneShotEvent::OneShotEvent(bool signaled) : signaled_(signaled) {
  39   thread_checker_.DetachFromThread();
  40 }
  41 OneShotEvent::~OneShotEvent() {}
  42
  43 void OneShotEvent::Post(const tracked_objects::Location& from_here,
  44                         const base::Closure& task) const {
  45   PostImpl(
  46       from_here, task, base::MessageLoopProxy::current(), base::TimeDelta());
  47 }
  48
  49 void OneShotEvent::Post(const tracked_objects::Location& from_here,
  50                         const base::Closure& task,
  51                         const scoped_refptr<TaskRunner>& runner) const {
  52   PostImpl(from_here, task, runner, base::TimeDelta());
  53 }
  54
  55 void OneShotEvent::PostDelayed(const tracked_objects::Location& from_here,
  56                                const base::Closure& task,
  57                                const base::TimeDelta& delay) const {
  58   PostImpl(from_here, task, base::MessageLoopProxy::current(), delay);
  59 }
  60
  61 void OneShotEvent::Signal() {
  62   DCHECK(thread_checker_.CalledOnValidThread());
  63
  64   CHECK(!signaled_) << "Only call Signal once.";
  65
  66   signaled_ = true;
  67   // After this point, a call to Post() from one of the queued tasks
  68   // could proceed immediately, but the fact that this object is
  69   // single-threaded prevents that from being relevant.
  70
  71   // We could randomize tasks_ in debug mode in order to check that
  72   // the order doesn't matter...
  73   for (size_t i = 0; i < tasks_.size(); ++i) {
  74     const TaskInfo& task = tasks_[i];
  75     if (task.delay != base::TimeDelta())
  76       task.runner->PostDelayedTask(task.from_here, task.task, task.delay);
  77     else
  78       task.runner->PostTask(task.from_here, task.task);
  79   }
  80 }
  81
  82 void OneShotEvent::PostImpl(const tracked_objects::Location& from_here,
  83                             const base::Closure& task,
  84                             const scoped_refptr<TaskRunner>& runner,
  85                             const base::TimeDelta& delay) const {
  86   DCHECK(thread_checker_.CalledOnValidThread());
  87
  88   if (is_signaled()) {
  89     if (delay != base::TimeDelta())
  90       runner->PostDelayedTask(from_here, task, delay);
  91     else
  92       runner->PostTask(from_here, task);
  93   } else {
  94     tasks_.push_back(TaskInfo(from_here, runner, task, delay));
  95   }
  96 }
  97
  98 }  // namespace extensions