Put back r1891 with some task deletion disabled to maintain backwards compat...

base/message_loop_unittest.cc

 // Copyright (c) 2006-2008 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/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 272 matching lines @@
 
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), 1);
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time2 > run_time1);
 }
 
+class RecordDeletionTask : public Task {
+ public:
+  RecordDeletionTask(Task* post_on_delete, bool* was_deleted)
+      : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {
+  }
+  ~RecordDeletionTask() {
+    *was_deleted_ = true;
+    if (post_on_delete_)
+      MessageLoop::current()->PostTask(FROM_HERE, post_on_delete_);
+  }
+  virtual void Run() {}
+ private:
+  Task* post_on_delete_;
+  bool* was_deleted_;
+};
+
+void RunTest_EnsureTaskDeletion(MessageLoop::Type message_loop_type) {
+  bool a_was_deleted = false;
+  bool b_was_deleted = false;
+  {
+    MessageLoop loop(message_loop_type);
+    loop.PostTask(
+        FROM_HERE, new RecordDeletionTask(NULL, &a_was_deleted));
+    loop.PostDelayedTask(
+        FROM_HERE, new RecordDeletionTask(NULL, &b_was_deleted), 1000);
+  }
+  EXPECT_TRUE(a_was_deleted);
+  EXPECT_TRUE(b_was_deleted);
+}
+
+void RunTest_EnsureTaskDeletion_Chain(MessageLoop::Type message_loop_type) {
+  bool a_was_deleted = false;
+  bool b_was_deleted = false;
+  bool c_was_deleted = false;
+  {
+    MessageLoop loop(message_loop_type);
+    RecordDeletionTask* a = new RecordDeletionTask(NULL, &a_was_deleted);
+    RecordDeletionTask* b = new RecordDeletionTask(a, &b_was_deleted);
+    RecordDeletionTask* c = new RecordDeletionTask(b, &c_was_deleted);
+    loop.PostTask(FROM_HERE, c);
+  }
+  EXPECT_TRUE(a_was_deleted);
+  EXPECT_TRUE(b_was_deleted);
+  EXPECT_TRUE(c_was_deleted);
+}
+
 class NestingTest : public Task {
  public:
   explicit NestingTest(int* depth) : depth_(depth) {
   }
   void Run() {
     if (*depth_ > 0) {
       *depth_ -= 1;
       MessageLoop::current()->PostTask(FROM_HERE, new NestingTest(depth_));
 
       MessageLoop::current()->SetNestableTasksAllowed(true);
@@ skipping 739 matching lines @@
   RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, PostDelayedTask_InPostOrder_3) {
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, EnsureTaskDeletion) {
+  RunTest_EnsureTaskDeletion(MessageLoop::TYPE_DEFAULT);
+  RunTest_EnsureTaskDeletion(MessageLoop::TYPE_UI);
+  RunTest_EnsureTaskDeletion(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, EnsureTaskDeletion_Chain) {
+  RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_DEFAULT);
+  RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_UI);
+  RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_IO);
+}
+
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Crasher) {
   RunTest_Crasher(MessageLoop::TYPE_DEFAULT);
   RunTest_Crasher(MessageLoop::TYPE_UI);
   RunTest_Crasher(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, CrasherNasty) {
   RunTest_CrasherNasty(MessageLoop::TYPE_DEFAULT);
   RunTest_CrasherNasty(MessageLoop::TYPE_UI);
@@ skipping 48 matching lines @@
 TEST(MessageLoopTest, AutoresetEvents) {
   // This test requires an IO loop
   RunTest_AutoresetEvents(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 #endif  // defined(OS_WIN)