Clear PostTaskAndReply task on the destination thread (3)

base/threading/post_task_and_reply_impl_unittest.cc

 // 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 
 namespace base {
 namespace internal {
 
@@ skipping 41 matching lines @@
     EXPECT_TRUE(*delete_flag);
     ReplyMock();
   }
 
   MOCK_METHOD0(ReplyMock, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockObject);
 };
 
+class WrappedTaskRunner : public SingleThreadTaskRunner {

[gab, 2017/03/29 18:21:35]

Hmmm sorry I wasn't clear, I didn't mean to make the test more complex, but
rather that I think we can simplify it (no longer need to verify in
MockObject::Reply()).

We can simply do:

EXPECT_TRUE(post_runner->HasPendingTask());
EXPECT_FALSE(reply_runner->HasPendingTask());
EXPECT_FALSE(delete_flag);

post_runner->RunUntilIdle();

EXPECT_FALSE(post_runner->HasPendingTask());
EXPECT_TRUE(reply_runner->HasPendingTask());
EXPECT_TRUE(delete_flag);

reply_runner->RunUntilIdle();

EXPECT_FALSE(post_runner->HasPendingTask());
EXPECT_FALSE(reply_runner->HasPendingTask());
EXPECT_TRUE(delete_flag);


without needing MockObject nor WrappedTaskRunner (don't think it matters to
verify the state when posting specifically).

[tzik, 2017/03/30 09:01:18]

Ah, sorry for confusion. Updated the test.

+ public:
+  explicit WrappedTaskRunner(
+      scoped_refptr<SingleThreadTaskRunner> underlying_task_runner)
+      : underlying_task_runner_(std::move(underlying_task_runner)) {}
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       Closure task,
+                       base::TimeDelta delay) override {
+    if (post_task_hook_)
+      std::move(post_task_hook_).Run();
+    return underlying_task_runner_->PostDelayedTask(from_here, std::move(task),
+                                                    delay);
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  Closure task,
+                                  base::TimeDelta delay) override {
+    if (post_task_hook_)
+      std::move(post_task_hook_).Run();
+    return underlying_task_runner_->PostNonNestableDelayedTask(
+        from_here, std::move(task), delay);
+  }
+
+  void set_post_task_hook(OnceClosure hook) {
+    post_task_hook_ = std::move(hook);
+  }
+
+  bool has_post_task_hook() const { return !post_task_hook_.is_null(); }
+
+  bool RunsTasksOnCurrentThread() const override {
+    return underlying_task_runner_->RunsTasksOnCurrentThread();
+  }
+
+ private:
+  ~WrappedTaskRunner() override {}
+
+  scoped_refptr<SingleThreadTaskRunner> underlying_task_runner_;
+  OnceClosure post_task_hook_;
+
+  DISALLOW_COPY_AND_ASSIGN(WrappedTaskRunner);
+};
+
 }  // namespace
 
 TEST(PostTaskAndReplyImplTest, PostTaskAndReply) {
   scoped_refptr<TestSimpleTaskRunner> post_runner(new TestSimpleTaskRunner);
   scoped_refptr<TestSimpleTaskRunner> reply_runner(new TestSimpleTaskRunner);
-  ThreadTaskRunnerHandle task_runner_handle(reply_runner);
+  scoped_refptr<WrappedTaskRunner> wrapped_reply_runner(
+      new WrappedTaskRunner(reply_runner));
+  ThreadTaskRunnerHandle task_runner_handle(wrapped_reply_runner);
 
   testing::StrictMock<MockObject> mock_object;
   bool delete_flag = false;
 
+  auto expect_true = [](bool* delete_flag) { EXPECT_TRUE(*delete_flag); };
+
+  // Expect the posted callback is destroyed before the reply task is scheduled.
+  wrapped_reply_runner->set_post_task_hook(
+      base::BindOnce(expect_true, &delete_flag));
+
   EXPECT_TRUE(
       PostTaskAndReplyTaskRunner(post_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 |reply_runner|.
   EXPECT_FALSE(reply_runner->HasPendingTask());
 
   // Expect the task to be posted to |post_runner|.
   EXPECT_TRUE(post_runner->HasPendingTask());
   EXPECT_CALL(mock_object, Task(_));
   post_runner->RunUntilIdle();
   testing::Mock::VerifyAndClear(&mock_object);
 
-  // Expect the task's argument not to have been deleted yet.
-  EXPECT_FALSE(delete_flag);
+  // Expect the task's argument to have been deleted.
+  EXPECT_FALSE(wrapped_reply_runner->has_post_task_hook());
+  EXPECT_TRUE(delete_flag);
 
   // Expect the reply to be posted to |reply_runner|.
   EXPECT_FALSE(post_runner->HasPendingTask());
   EXPECT_TRUE(reply_runner->HasPendingTask());
   EXPECT_CALL(mock_object, ReplyMock());
   reply_runner->RunUntilIdle();
   testing::Mock::VerifyAndClear(&mock_object);
   EXPECT_TRUE(delete_flag);
 
   // Expect no pending task in |post_runner| and |reply_runner|.
   EXPECT_FALSE(post_runner->HasPendingTask());
   EXPECT_FALSE(reply_runner->HasPendingTask());
 }
 
 }  // namespace internal
 }  // namespace base