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..5df8761965e63207a49911e9a1d6d198db8a47e3
--- /dev/null
+++ b/base/deferred_sequenced_task_runner_unittest.cc
@@ -0,0 +1,114 @@
+// 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 "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+template<size_t N>
+std::vector<int> MakeVector(const int (&data)[N] ) {
+  return std::vector<int>(data, data+N);
+}
+
+class DeferredSequencedTaskRunnerTest : public testing::Test {

[Jeffrey Yasskin, 2013/04/03 16:25:35]

You should probably include a test that adds elements from multiple threads, and
calls Start() during that set of PostTask()s, so that tsan can catch any races.

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

Done.

+ public:

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

There's no need for this to be public. GTest will subclass this fixture and call
the public constructor for the subclass. You should probably move this to the
protected section.

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

Done.

+  DeferredSequencedTaskRunnerTest() : loop_() {
+  }
+
+  void ExecuteTask(int task_id) {
+    executed_tasks_ids_.push_back(task_id);
+  }
+
+ protected:
+  virtual void SetUp() {

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

Since you have a constructor, why not move this into the constructor too?

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

Done.

+    runner_ =
+        new base::DeferredSequencedTaskRunner(loop_.message_loop_proxy());
+  }
+
+  std::vector<int> executed_tasks_ids_;

[Jeffrey Yasskin, 2013/04/03 16:25:35]

s/tasks/task/?

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

Done.

+  MessageLoop loop_;
+  scoped_refptr<base::DeferredSequencedTaskRunner> runner_;
+};
+
+TEST_F(DeferredSequencedTaskRunnerTest, Stopped) {
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_TRUE(executed_tasks_ids_.empty());
+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, Start) {
+  runner_->Start();
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_EQ(MakeVector<1>({1}), executed_tasks_ids_);

[Jeffrey Yasskin, 2013/04/03 16:25:35]

Try including gmock.h and then using

EXPECT_THAT(executed_tasks_ids_, testing::ElementsAre(1));

(https://code.google.com/p/googlemock/wiki/CheatSheet#Container_Matchers)

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

Thanks for the tip !!!

+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, StartWithMultipleElements) {

[Jeffrey Yasskin, 2013/04/03 16:25:35]

You probably don't need to test single and multiple elements separately.

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

I'll keep them for now. Let me know if you strongly feel I should remove them.

+  runner_->Start();
+  for (int i = 1; i < 5; ++i) {
+    runner_->PostTask(FROM_HERE,
+                      base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                                 base::Unretained(this),
+                                 i));
+  }
+  loop_.RunUntilIdle();
+  EXPECT_EQ(MakeVector<4>({1, 2,3, 4}), executed_tasks_ids_);

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

looks like a formatting typo

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

Done.

+}
+
+TEST_F(DeferredSequencedTaskRunnerTest, DeferredStart) {
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               1));
+  loop_.RunUntilIdle();
+  EXPECT_TRUE(executed_tasks_ids_.empty());
+
+  runner_->Start();
+  loop_.RunUntilIdle();
+  EXPECT_EQ(MakeVector<1>({1}), executed_tasks_ids_);
+
+  runner_->PostTask(FROM_HERE,
+                    base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                               base::Unretained(this),
+                               2));
+  loop_.RunUntilIdle();
+  EXPECT_EQ(MakeVector<2>({1, 2}), executed_tasks_ids_);
+}
+
+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_tasks_ids_.empty());
+
+  runner_->Start();
+
+  for (int i = 5; i < 10; ++i) {
+    runner_->PostTask(FROM_HERE,
+                      base::Bind(&DeferredSequencedTaskRunnerTest::ExecuteTask,
+                                 base::Unretained(this),
+                                 i));
+  }
+  loop_.RunUntilIdle();
+  EXPECT_EQ(MakeVector<9>({1, 2, 3, 4, 5, 6, 7, 8, 9}), executed_tasks_ids_);
+}
+
+}  // namespace