Delay bookmarks load while the profile is loading.

base/deferred_sequenced_task_runner.h

+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_
+#define BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_
+
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
+#include "base/time.h"
+#include "base/tracked_objects.h"
+
+namespace base {
+
+// A DeferredSequencedTaskRunner is a subclass of SequencedTaskRunner that
+// queues up all requests until the first call to Start() is issued.
+class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner {
+ public:
+  explicit DeferredSequencedTaskRunner(
+      const scoped_refptr<SequencedTaskRunner>& target_runner);
+
+  // TaskRunner implementation
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const Closure& task,
+                               TimeDelta delay) OVERRIDE;
+
+  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+
+  // SequencedTaskRunner implementation
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const Closure& task,
+      TimeDelta delay) OVERRIDE;
+
+  // Start the execution - posts all tasks in the |deferred_tasks_queue_| to
+  // the target executor. The deferred tasks are posted with their initial
+  // delay, meaning that the task execution delay is actually measured from
+  // Start.
+  // Fails when called a second time.
+  void Start();
+
+ private:
+  struct DeferredTask  {
+    DeferredTask();
+    ~DeferredTask();
+    tracked_objects::Location posted_from;
+    Closure task;
+    // The delay this task was initially posted with.
+    TimeDelta delay;
+    bool is_non_nestable;
+  };
+
+  virtual ~DeferredSequencedTaskRunner();
+
+  // Creates a |Task| object and adds it to |deferred_tasks_queue_|.
+  void QueueDeferredTask(const tracked_objects::Location& from_here,
+                         const Closure& task,
+                         TimeDelta delay,
+                         bool is_non_nestable);
+
+  mutable Lock lock_;
+
+  // True if this DeferredSequencedTaskRunner has already been started.
+  bool started_;
+
+  // Target task runner that executes the tasks.
+  const scoped_refptr<SequencedTaskRunner> target_task_runner_;
+
+  // Queue of tasks to be posted to |target_task_runner_| when this
+  // |DeferredSequencedTaskRunner| is started.
+  std::vector<DeferredTask> deferred_tasks_queue_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeferredSequencedTaskRunner);
+};
+
+}  // namespace base
+
+#endif  // BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_