Clear PostTaskAndReply task on the destination thread (3)

base/message_loop/message_loop_task_runner_unittest.cc

 // Copyright (c) 2012 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/message_loop/message_loop_task_runner.h"
 
 #include <memory>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 109 matching lines @@
   // Die if base::Bind doesn't retain a reference to the recorders.
   task_recorder = NULL;
   reply_recorder = NULL;
   ASSERT_FALSE(task_deleted_on);
   ASSERT_FALSE(reply_deleted_on);
 
   UnblockTaskThread();
   RunLoop().Run();
 
   EXPECT_EQ(task_thread_.message_loop(), task_run_on);
-  EXPECT_EQ(current_loop_.get(), task_deleted_on);
+  EXPECT_EQ(task_thread_.message_loop(), task_deleted_on);
   EXPECT_EQ(current_loop_.get(), reply_run_on);
   EXPECT_EQ(current_loop_.get(), reply_deleted_on);
   EXPECT_LT(task_delete_order, reply_delete_order);
 }
 
 TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReplyOnDeletedThreadDoesNotLeak) {
   MessageLoop* task_run_on = NULL;
   MessageLoop* task_deleted_on = NULL;
   int task_delete_order = -1;
   MessageLoop* reply_run_on = NULL;
@@ skipping 52 matching lines @@
 
   RunLoop().Run();
 
   EXPECT_EQ(current_loop_.get(), task_run_on);
   EXPECT_EQ(current_loop_.get(), task_deleted_on);
   EXPECT_EQ(current_loop_.get(), reply_run_on);
   EXPECT_EQ(current_loop_.get(), reply_deleted_on);
   EXPECT_LT(task_delete_order, reply_delete_order);
 }
 
-TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReply_DeadReplyLoopDoesNotDelete) {
+TEST_F(MessageLoopTaskRunnerTest,
+       PostTaskAndReply_DeadReplyTaskRunnerBehavior) {
   // Annotate the scope as having memory leaks to suppress heapchecker reports.
   ANNOTATE_SCOPED_MEMORY_LEAK;
   MessageLoop* task_run_on = NULL;
   MessageLoop* task_deleted_on = NULL;
   int task_delete_order = -1;
   MessageLoop* reply_run_on = NULL;
   MessageLoop* reply_deleted_on = NULL;
   int reply_delete_order = -1;
 
   scoped_refptr<LoopRecorder> task_recorder =
@@ skipping 16 matching lines @@
 
   // Mercilessly whack the current loop before |reply| gets to run.
   current_loop_.reset();
 
   // This should ensure the relay has been run.  We need to record the
   // MessageLoop pointer before stopping the thread because Thread::Stop() will
   // NULL out its own pointer.
   MessageLoop* task_loop = task_thread_.message_loop();
   task_thread_.Stop();
 
+  // Even if the reply task runner is already gone, the original task should
+  // already be deleted. However, the reply which hasn't executed yet should
+  // leak to avoid thread-safety issues.
   EXPECT_EQ(task_loop, task_run_on);
-  ASSERT_FALSE(task_deleted_on);
+  EXPECT_EQ(task_loop, task_deleted_on);
   EXPECT_FALSE(reply_run_on);
   ASSERT_FALSE(reply_deleted_on);
-  EXPECT_EQ(task_delete_order, reply_delete_order);
 
   // The PostTaskAndReplyRelay is leaked here.  Even if we had a reference to
   // it, we cannot just delete it because PostTaskAndReplyRelay's destructor
   // checks that MessageLoop::current() is the the same as when the
   // PostTaskAndReplyRelay object was constructed.  However, this loop must have
   // already been deleted in order to perform this test.  See
   // http://crbug.com/86301.
 }
 
 class MessageLoopTaskRunnerThreadingTest : public testing::Test {
@@ skipping 98 matching lines @@
         new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
     test_thread->Start();
     task_runner = test_thread->task_runner();
   }
   bool ret = task_runner->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 }  // namespace base