Delay bookmarks load while the profile is loading.

base/deferred_sequenced_task_runner_unittest.cc

Index: base/deferred_sequenced_task_runner_unittest.cc
diff --git a/base/deferred_sequenced_task_runner_unittest.cc b/base/deferred_sequenced_task_runner_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5c654ca359dc66eabdb1873bc4b45ddae485e801
--- /dev/null
+++ b/base/deferred_sequenced_task_runner_unittest.cc
@@ -0,0 +1,136 @@
+// 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.
+
+#include "base/deferred_sequenced_task_runner.h"
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
+#include "base/threading/thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class DeferredSequencedTaskRunnerTest : public testing::Test {
+ public :

[Jeffrey Yasskin, 2013/04/08 19:58:30]

No space between "public" and ":". 

[msarda, 2013/04/09 07:20:11]

Done.

+  void ExecuteTask(int task_id) {
+    base::AutoLock lock(lock_);
+    executed_task_ids_.push_back(task_id);
+  }
+
+ protected:
+  DeferredSequencedTaskRunnerTest() : loop_(),

[Jeffrey Yasskin, 2013/04/08 19:58:30]

I believe the style guide says to line up "loop_" and "runner_", which probably
implies putting ": loop_()," on the next line.

[msarda, 2013/04/09 07:20:11]

Done.

+      runner_(
+          new base::DeferredSequencedTaskRunner(loop_.message_loop_proxy()) {
+  }
+
+  MessageLoop loop_;
+  scoped_refptr<base::DeferredSequencedTaskRunner> runner_;
+  mutable base::Lock lock_;
+  std::vector<int> executed_task_ids_;
+};
+
+TEST_F(DeferredSequencedTaskRunnerTest, Stopped) {
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_TRUE(executed_task_ids_.empty()) << executed_task_ids_[0];

[Jeffrey Yasskin, 2013/04/08 19:58:30]

You can use "EXPECT_THAT(executed_task_ids_, testing::ElementsAre())" to assert
emptiness in a way that'll print the elements if it fails.

[msarda, 2013/04/09 07:20:11]

Done.

+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, Start) {
+  runner_->Start();
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1));
+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, StartWithMultipleElements) {
+  runner_->Start();
+  for (int i = 1; i < 5; ++i) {
+    runner_->PostTask(FROM_HERE,
+                      base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                                 base::Unretained(this),
+                                 i));
+  }
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2, 3, 4));
+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, DeferredStart) {
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_TRUE(executed_task_ids_.empty());
+
+  runner_->Start();
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1));
+
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               2));
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2));
+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, DeferredStartWithMultipleElements) {
+  for (int i = 1; i < 5; ++i) {
+    runner_->PostTask(FROM_HERE,
+                      base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                                 base::Unretained(this),
+                                 i));
+  }
+  loop_.RunUntilIdle();
+  EXPECT_TRUE(executed_task_ids_.empty());
+
+  runner_->Start();
+
+  for (int i = 5; i < 9; ++i) {
+    runner_->PostTask(FROM_HERE,
+                      base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                                 base::Unretained(this),
+                                 i));
+  }
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2,3, 4, 5, 6, 7, 8));

[Jeffrey Yasskin, 2013/04/08 19:58:30]

Missing space between 2 and 3.

[msarda, 2013/04/09 07:20:11]

Done.

+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, DeferredStartWithMultipleThreads) {
+  {
+    base::Thread thread1("DeferredSequencedTaskRunnerTestThread1");
+    base::Thread thread2("DeferredSequencedTaskRunnerTestThread2");
+    thread1.Start();
+    thread2.Start();
+    for (int i = 0; i < 5; ++i) {
+      thread1.message_loop()->PostTask(FROM_HERE,
+          base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                     base::Unretained(this),
+                     2 * i));
+      thread2.message_loop()->PostTask(FROM_HERE,
+          base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                     base::Unretained(this),
+                     2 * i + 1));
+      if (i == 2)
+        runner_->Start();

[Jeffrey Yasskin, 2013/04/08 19:58:30]

Post this to one of the threads too, or it's likely to run before either of the
threads has actually started picking up work.

[msarda, 2013/04/09 07:20:11]

Done.

+    }
+  }
+
+  loop_.RunUntilIdle();
+  EXPECT_THAT(executed_task_ids_,
+      testing::WhenSorted(testing::ElementsAre(0, 1, 2,3, 4, 5, 6, 7, 8, 9)));

[Jeffrey Yasskin, 2013/04/08 19:58:30]

Missing space between 2 and 3.

[msarda, 2013/04/09 07:20:11]

Done.

+}
+
+}  // namespace