Home | History | Annotate | Download | only in trees
      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 #ifndef CC_TREES_BLOCKING_TASK_RUNNER_H_
      6 #define CC_TREES_BLOCKING_TASK_RUNNER_H_
      7 
      8 #include <vector>
      9 
     10 #include "base/location.h"
     11 #include "base/memory/ref_counted.h"
     12 #include "base/single_thread_task_runner.h"
     13 #include "base/synchronization/lock.h"
     14 #include "base/threading/platform_thread.h"
     15 #include "cc/base/cc_export.h"
     16 
     17 namespace cc {
     18 
     19 // This class wraps a SingleThreadTaskRunner but allows posted tasks to be
     20 // run without a round trip through the message loop. This shortcutting
     21 // removes guarantees about ordering. Tasks posted while the
     22 // BlockingTaskRunner is in a capturing state will run in order, and tasks
     23 // posted while the BlockingTaskRunner is /not/ in a capturing state will
     24 // run in order, but the two sets of tasks will *not* run in order relative
     25 // to when they were posted.
     26 //
     27 // To use this class, post tasks to the task runner returned by
     28 // BlockingTaskRunner::current() on the thread you want the tasks to run.
     29 // Hold a reference to the BlockingTaskRunner as long as you intend to
     30 // post tasks to it.
     31 //
     32 // Then, on the thread from which the BlockingTaskRunner was created, you
     33 // may instantiate a BlockingTaskRunner::CapturePostTasks. While this object
     34 // exists, the task runner will collect any PostTasks called on it, posting
     35 // tasks to that thread from anywhere. This CapturePostTasks object provides
     36 // a window in time where tasks can shortcut past the MessageLoop. As soon
     37 // as the CapturePostTasks object is destroyed (goes out of scope), all
     38 // tasks that had been posted to the thread during the window will be exectuted
     39 // immediately.
     40 //
     41 // Beware of re-entrancy, make sure the CapturePostTasks object is destroyed at
     42 // a time when it makes sense for the embedder to call arbitrary things.
     43 class CC_EXPORT BlockingTaskRunner
     44     : public base::RefCountedThreadSafe<BlockingTaskRunner> {
     45  public:
     46   // Returns the BlockingTaskRunner for the current thread, creating one if
     47   // necessary.
     48   static scoped_refptr<BlockingTaskRunner> current();
     49 
     50   // While an object of this type is held alive on a thread, any tasks
     51   // posted to the thread will be captured and run as soon as the object
     52   // is destroyed, shortcutting past the MessageLoop.
     53   class CC_EXPORT CapturePostTasks {
     54    public:
     55     CapturePostTasks();
     56     ~CapturePostTasks();
     57 
     58    private:
     59     scoped_refptr<BlockingTaskRunner> blocking_runner_;
     60 
     61     DISALLOW_COPY_AND_ASSIGN(CapturePostTasks);
     62   };
     63 
     64   // True if tasks posted to the BlockingTaskRunner will run on the current
     65   // thread.
     66   bool BelongsToCurrentThread();
     67 
     68   // Posts a task using the contained SingleThreadTaskRunner unless |capture_|
     69   // is true. When |capture_| is true, tasks posted will be caught and stored
     70   // until the capturing stops. At that time the tasks will be run directly
     71   // instead of being posted to the SingleThreadTaskRunner.
     72   bool PostTask(const tracked_objects::Location& from_here,
     73                 const base::Closure& task);
     74 
     75  private:
     76   friend class base::RefCountedThreadSafe<BlockingTaskRunner>;
     77 
     78   explicit BlockingTaskRunner(
     79       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
     80   virtual ~BlockingTaskRunner();
     81 
     82   void SetCapture(bool capture);
     83 
     84   base::PlatformThreadId thread_id_;
     85   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     86 
     87   base::Lock lock_;
     88   int capture_;
     89   std::vector<base::Closure> captured_tasks_;
     90 };
     91 
     92 }  // namespace cc
     93 
     94 #endif  // CC_TREES_BLOCKING_TASK_RUNNER_H_
     95