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..48d59c6d7ee0b85a08dd211387731ea836d9dbfd
--- /dev/null
+++ b/base/threading/post_task_and_reply_impl_unittest.cc
@@ -0,0 +1,116 @@
+// 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"
+
+using ::testing::_;
+
+namespace base {
+namespace internal {
+
+namespace {
+
+class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl {
+ public:
+  explicit PostTaskAndReplyTaskRunner(TaskRunner* destination)
+      : destination_(destination) {}
+
+ private:
+  bool PostTask(const tracked_objects::Location& from_here,
+                const Closure& task) override {
+    return destination_->PostTask(from_here, task);
+  }
+
+  // Non-owning.
+  TaskRunner* const destination_;
+};
+
+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_);
+  }
+
+ private:
+  friend class RefCounted<ObjectToDelete>;
+  ~ObjectToDelete() { *delete_flag_ = true; }
+
+  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 deletion flag to be set before the reply runs.
+    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);

[danakj, 2016/07/29 19:52:06]

nit: post_runner and reply_runner as names maybe?

[fdoray, 2016/07/29 20:14:42]

Done.

+  scoped_refptr<TestSimpleTaskRunner> current_runner(new TestSimpleTaskRunner);
+  SequencedTaskRunnerHandle sequenced_task_runner_handle(current_runner);
+
+  testing::StrictMock<MockObject> mock_object;
+  bool delete_flag = false;
+
+  EXPECT_TRUE(
+      PostTaskAndReplyTaskRunner(task_runner.get())
+          .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))));
+
+  // Expect no reply in |current_runner|.
+  EXPECT_FALSE(current_runner->HasPendingTask());
+
+  // Expect the task to be posted to |task_runner|.
+  EXPECT_TRUE(task_runner->HasPendingTask());
+  EXPECT_CALL(mock_object, Task(_));
+  task_runner->RunUntilIdle();
+  testing::Mock::VerifyAndClear(&mock_object);
+
+  // Expect the task's argument not to have been deleted yet.
+  EXPECT_FALSE(delete_flag);

[danakj, 2016/07/29 19:52:06]

can you EXPECT_TRUE the delete_flag at some point?

[fdoray, 2016/07/29 20:14:43]

Done.

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