webkit/dom_storage/dom_storage_task_runner.h

   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 #ifndef WEBKIT_DOM_STORAGE_DOM_STORAGE_TASK_RUNNER_
   6 #define WEBKIT_DOM_STORAGE_DOM_STORAGE_TASK_RUNNER_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/sequenced_task_runner.h"
  10 #include "base/threading/sequenced_worker_pool.h"
  11 #include "base/time.h"
  12 #include "webkit/storage/webkit_storage_export.h"
  13
  14 namespace base {
  15 class MessageLoopProxy;
  16 }
  17
  18 namespace dom_storage {
  19
  20 // DomStorage uses two task sequences (primary vs commit) to avoid
  21 // primary access from queuing up behind commits to disk.
  22 // * Initialization, shutdown, and administrative tasks are performed as
  23 //   shutdown-blocking primary sequence tasks.
  24 // * Tasks directly related to the javascript'able interface are performed
  25 //   as shutdown-blocking primary sequence tasks.
  26 //   TODO(michaeln): Skip tasks for reading during shutdown.
  27 // * Internal tasks related to committing changes to disk are performed as
  28 //   shutdown-blocking commit sequence tasks.
  29 class WEBKIT_STORAGE_EXPORT DomStorageTaskRunner : public base::TaskRunner {
  30  public:
  31   enum SequenceID {
  32     PRIMARY_SEQUENCE,
  33     COMMIT_SEQUENCE
  34   };
  35
  36   // The PostTask() and PostDelayedTask() methods defined by TaskRunner
  37   // post shutdown-blocking tasks on the primary sequence.
  38   virtual bool PostDelayedTask(
  39       const tracked_objects::Location& from_here,
  40       const base::Closure& task,
  41       base::TimeDelta delay) = 0;
  42
  43   // Posts a shutdown blocking task to |sequence_id|.
  44   virtual bool PostShutdownBlockingTask(
  45       const tracked_objects::Location& from_here,
  46       SequenceID sequence_id,
  47       const base::Closure& task) = 0;
  48
  49   // The TaskRunner override returns true if the current thread is running
  50   // on the primary sequence.
  51   virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
  52
  53   // Returns true if the current thread is running on the given |sequence_id|.
  54   virtual bool IsRunningOnSequence(SequenceID sequence_id) const = 0;
  55   bool IsRunningOnPrimarySequence() const {
  56     return IsRunningOnSequence(PRIMARY_SEQUENCE);
  57   }
  58   bool IsRunningOnCommitSequence() const {
  59     return IsRunningOnSequence(COMMIT_SEQUENCE);
  60   }
  61
  62  protected:
  63   virtual ~DomStorageTaskRunner() {}
  64 };
  65
  66 // A derived class used in chromium that utilizes a SequenceWorkerPool
  67 // under dom_storage specific SequenceTokens. The |delayed_task_loop|
  68 // is used to delay scheduling on the worker pool.
  69 class WEBKIT_STORAGE_EXPORT DomStorageWorkerPoolTaskRunner :
  70       public DomStorageTaskRunner {
  71  public:
  72   DomStorageWorkerPoolTaskRunner(
  73       base::SequencedWorkerPool* sequenced_worker_pool,
  74       base::SequencedWorkerPool::SequenceToken primary_sequence_token,
  75       base::SequencedWorkerPool::SequenceToken commit_sequence_token,
  76       base::MessageLoopProxy* delayed_task_loop);
  77
  78   virtual bool PostDelayedTask(
  79       const tracked_objects::Location& from_here,
  80       const base::Closure& task,
  81       base::TimeDelta delay) OVERRIDE;
  82
  83   virtual bool PostShutdownBlockingTask(
  84       const tracked_objects::Location& from_here,
  85       SequenceID sequence_id,
  86       const base::Closure& task) OVERRIDE;
  87
  88   virtual bool IsRunningOnSequence(SequenceID sequence_id) const OVERRIDE;
  89
  90  protected:
  91   virtual ~DomStorageWorkerPoolTaskRunner();
  92
  93  private:
  94
  95   base::SequencedWorkerPool::SequenceToken IDtoToken(SequenceID id) const;
  96
  97   const scoped_refptr<base::MessageLoopProxy> message_loop_;
  98   const scoped_refptr<base::SequencedWorkerPool> sequenced_worker_pool_;
  99   base::SequencedWorkerPool::SequenceToken primary_sequence_token_;
 100   base::SequencedWorkerPool::SequenceToken commit_sequence_token_;
 101 };
 102
 103 // A derived class used in unit tests that ignores all delays so
 104 // we don't block in unit tests waiting for timeouts to expire.
 105 // There is no distinction between [non]-shutdown-blocking or
 106 // the primary sequence vs the commit sequence in the mock,
 107 // all tasks are scheduled on |message_loop| with zero delay.
 108 class WEBKIT_STORAGE_EXPORT MockDomStorageTaskRunner :
 109       public DomStorageTaskRunner {
 110  public:
 111   explicit MockDomStorageTaskRunner(base::MessageLoopProxy* message_loop);
 112
 113   virtual bool PostDelayedTask(
 114       const tracked_objects::Location& from_here,
 115       const base::Closure& task,
 116       base::TimeDelta delay) OVERRIDE;
 117
 118   virtual bool PostShutdownBlockingTask(
 119       const tracked_objects::Location& from_here,
 120       SequenceID sequence_id,
 121       const base::Closure& task) OVERRIDE;
 122
 123   virtual bool IsRunningOnSequence(SequenceID sequence_id) const OVERRIDE;
 124
 125  protected:
 126   virtual ~MockDomStorageTaskRunner();
 127
 128  private:
 129   const scoped_refptr<base::MessageLoopProxy> message_loop_;
 130 };
 131
 132 }  // namespace dom_storage
 133
 134 #endif  // WEBKIT_DOM_STORAGE_DOM_STORAGE_TASK_RUNNER_