Support PostTaskAndReply from a sequenced task.

base/threading/post_task_and_reply_impl_unittest.cc

Index: base/threading/post_task_and_reply_impl_unittest.cc
diff --git a/base/threading/post_task_and_reply_impl_unittest.cc b/base/threading/post_task_and_reply_impl_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..21bff1b2e3923a1df6047bf65c655ce82af5c7ef
--- /dev/null
+++ b/base/threading/post_task_and_reply_impl_unittest.cc
@@ -0,0 +1,94 @@
+// Copyright 2016 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/threading/post_task_and_reply_impl.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+class ObjectToDelete : public RefCounted<ObjectToDelete> {
+ public:
+  // |delete_flag| is set to true when this object is deleted
+  ObjectToDelete(bool* delete_flag) : delete_flag_(delete_flag) {
+    EXPECT_FALSE(*delete_flag_);
+  }
+  ~ObjectToDelete() { *delete_flag_ = true; }

[gab, 2016/07/25 17:57:44]

Destructor private for RefCounted objects

[fdoray, 2016/07/25 20:40:04]

Done.

+
+ private:
+  friend class RefCounted<ObjectToDelete>;
+  bool* const delete_flag_;
+
+  DISALLOW_COPY_AND_ASSIGN(ObjectToDelete);
+};
+
+class MockObject {
+ public:
+  MockObject() = default;
+
+  MOCK_METHOD1(Task, void(scoped_refptr<ObjectToDelete>));
+
+  void Reply(bool* delete_flag) {
+    // Expect the task's argument to be deleted before the reply runs.

[gab, 2016/07/25 17:57:44]

s/task's argument to be deleted/task's deletion flag to be set/

[fdoray, 2016/07/25 20:40:04]

Done.

+    EXPECT_TRUE(*delete_flag);
+    ReplyMock();
+  }
+
+  MOCK_METHOD0(ReplyMock, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockObject);
+};
+
+}  // namespace
+
+TEST(PostTaskAndReplyImplTest, PostTaskAndReply) {
+  scoped_refptr<TestSimpleTaskRunner> task_runner(new TestSimpleTaskRunner);

[gab, 2016/07/25 17:57:44]

Should TestSimpleTaskRunner grab SequenceTokens once they exist? Otherwise this
pattern of two TaskRunners which run on same underlying thread in unitests
doesn't exercise the Sequence/ThreadCheckers (they never have but now they could
:-))

[fdoray, 2016/07/25 20:40:04]

Created bug to remember to do this crbug.com/631186

+  scoped_refptr<TestSimpleTaskRunner> reply_runner(new TestSimpleTaskRunner);

[gab, 2016/07/25 17:57:44]

s/reply_runner/current_runner/ (i.e. it's not a new target, rather the reply
binds to "current")

[fdoray, 2016/07/25 20:40:04]

Done.

+  SequencedTaskRunnerHandle sequenced_task_runner_handle(reply_runner);
+
+  testing::StrictMock<MockObject> mock_object;
+  bool delete_flag = false;
+
+  EXPECT_TRUE(internal::PostTaskAndReply(
+      FROM_HERE, Bind(&MockObject::Task, Unretained(&mock_object),
+                      make_scoped_refptr(new ObjectToDelete(&delete_flag))),
+      Bind(&MockObject::Reply, Unretained(&mock_object),
+           Unretained(&delete_flag)),
+      Bind(&TestSimpleTaskRunner::PostTask, task_runner.get())));
+
+  // Expect no reply in |reply_runner|.
+  EXPECT_FALSE(reply_runner->HasPendingTask());
+
+  // Expect the task to be posted to |task_runner|.
+  EXPECT_TRUE(task_runner->HasPendingTask());
+  EXPECT_CALL(mock_object, Task(::testing::_));

[gab, 2016/07/25 17:57:44]

using testing::_;

after includes (same for other testing:: stuff, this is typically what is done
to avoid namespace cruft in gmock tests)

[fdoray, 2016/07/25 20:40:04]

Done.

+  task_runner->RunUntilIdle();
+  testing::Mock::VerifyAndClear(&mock_object);
+
+  // Expect the task's argument not to have been deleted yet.
+  EXPECT_FALSE(delete_flag);
+
+  // Expect the reply to be posted to |reply_runner|.

[gab, 2016/07/25 17:57:44]

EXPECT_FALSE(task_runner->HasPendingTask());
EXPECT_TRUE(current_runner->HasPendingTask());

[fdoray, 2016/07/25 20:40:04]

Done.

+  EXPECT_CALL(mock_object, ReplyMock());
+  reply_runner->RunUntilIdle();
+  testing::Mock::VerifyAndClear(&mock_object);
+
+  // Expect no pending task in |task_runner| and |reply_runner|.
+  EXPECT_FALSE(task_runner->HasPendingTask());
+  EXPECT_FALSE(reply_runner->HasPendingTask());
+}
+
+}  // namespace internal
+}  // namespace base