base/run_loop.cc

   1 // Copyright (c) 2012 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 "base/run_loop.h"
   6
   7 #include "base/bind.h"
   8 #include "base/tracked_objects.h"
   9
  10 #if defined(OS_WIN)
  11 #include "base/message_loop/message_pump_dispatcher.h"
  12 #endif
  13
  14 namespace base {
  15
  16 RunLoop::RunLoop()
  17     : loop_(MessageLoop::current()),
  18       previous_run_loop_(NULL),
  19       run_depth_(0),
  20       run_called_(false),
  21       quit_called_(false),
  22       running_(false),
  23       quit_when_idle_received_(false),
  24       weak_factory_(this) {
  25 #if defined(OS_WIN)
  26    dispatcher_ = NULL;
  27 #endif
  28 }
  29
  30 #if defined(OS_WIN)
  31 RunLoop::RunLoop(MessagePumpDispatcher* dispatcher)
  32     : loop_(MessageLoop::current()),
  33       previous_run_loop_(NULL),
  34       dispatcher_(dispatcher),
  35       run_depth_(0),
  36       run_called_(false),
  37       quit_called_(false),
  38       running_(false),
  39       quit_when_idle_received_(false),
  40       weak_factory_(this) {
  41 }
  42 #endif
  43
  44 RunLoop::~RunLoop() {
  45 }
  46
  47 void RunLoop::Run() {
  48   if (!BeforeRun())
  49     return;
  50
  51   // Use task stopwatch to exclude the loop run time from the current task, if
  52   // any.
  53   tracked_objects::TaskStopwatch stopwatch;
  54   stopwatch.Start();
  55   loop_->RunHandler();
  56   stopwatch.Stop();
  57
  58   AfterRun();
  59 }
  60
  61 void RunLoop::RunUntilIdle() {
  62   quit_when_idle_received_ = true;
  63   Run();
  64 }
  65
  66 void RunLoop::Quit() {
  67   quit_called_ = true;
  68   if (running_ && loop_->run_loop_ == this) {
  69     // This is the inner-most RunLoop, so quit now.
  70     loop_->QuitNow();
  71   }
  72 }
  73
  74 base::Closure RunLoop::QuitClosure() {
  75   return base::Bind(&RunLoop::Quit, weak_factory_.GetWeakPtr());
  76 }
  77
  78 bool RunLoop::BeforeRun() {
  79   DCHECK(!run_called_);
  80   run_called_ = true;
  81
  82   // Allow Quit to be called before Run.
  83   if (quit_called_)
  84     return false;
  85
  86   // Push RunLoop stack:
  87   previous_run_loop_ = loop_->run_loop_;
  88   run_depth_ = previous_run_loop_? previous_run_loop_->run_depth_ + 1 : 1;
  89   loop_->run_loop_ = this;
  90
  91   running_ = true;
  92   return true;
  93 }
  94
  95 void RunLoop::AfterRun() {
  96   running_ = false;
  97
  98   // Pop RunLoop stack:
  99   loop_->run_loop_ = previous_run_loop_;
 100
 101   // Execute deferred QuitNow, if any:
 102   if (previous_run_loop_ && previous_run_loop_->quit_called_)
 103     loop_->QuitNow();
 104 }
 105
 106 }  // namespace base