Delay bookmarks load while the profile is loading.

base/deferred_sequenced_task_runner.h

Index: base/deferred_sequenced_task_runner.h
diff --git a/base/deferred_sequenced_task_runner.h b/base/deferred_sequenced_task_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..c7c11c309b7a1b3565b26fd88184f57d930b41a3
--- /dev/null
+++ b/base/deferred_sequenced_task_runner.h
@@ -0,0 +1,84 @@
+// 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/memory/scoped_ptr.h"

[willchan no longer on Chromium, 2013/04/05 02:56:41]

Why?

[msarda, 2013/04/08 17:37:18]

Done.

+#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.

[willchan no longer on Chromium, 2013/04/05 02:56:41]

Start() to indicate it's a member function.

[msarda, 2013/04/08 17:37:18]

Done.

+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.
+  // Ignores the call if this task runner is already started.

[willchan no longer on Chromium, 2013/04/05 02:56:41]

This is all personal style preference, and despite what some people may say
there is no consensus in the overall project, but I personally disallowing
double calls. I think it's often benignly sloppy, but sometimes is indicative of
a bug. I personally err on the side of being a bit annoying and requiring extra
code to make sure people don't call this twice, in order to assure ourselves
that different subsystems using this shared DeferredSequencedTaskRunner properly
cooperate to make sure that it is not started until both subsystems are ready.

I leave it up to you, but I wanted to state my preference for you to consider in
case you had not considered yet.

[msarda, 2013/04/08 17:37:18]

I did consider it, but I can go either way. I changed its behavior.
Done.

+  void Start();
+
+ private:
+  virtual ~DeferredSequencedTaskRunner();
+
+  struct DeferredTask  {

[willchan no longer on Chromium, 2013/04/05 02:56:41]

Types go before destructors. Move this up.

[msarda, 2013/04/08 17:37:18]

Done.

+    DeferredTask();
+    ~DeferredTask();
+    tracked_objects::Location posted_from;
+    Closure task;
+    // The delay this task was initially posted with.
+    TimeDelta delay;
+    bool is_non_nestable;
+  };
+
+  // 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);
+
+  // 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_;
+
+  mutable Lock lock_;

[willchan no longer on Chromium, 2013/04/05 02:56:41]

Move this to be first. It guards all the other member variables, thus it should
outlive all the others.

[msarda, 2013/04/08 17:37:18]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(DeferredSequencedTaskRunner);
+};
+
+}  // namespace base
+
+#endif  // BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_