rollback r1891

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@1892 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 30 insertions, 98 deletions

diff --git a/base/message_loop.cc b/base/message_loop.cc
index 4f6f2fd..fffeb09 100644
--- a/base/message_loop.cc
+++ b/base/message_loop.cc
@@ -100,27 +100,25 @@ MessageLoop::~MessageLoop() {
   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
                     WillDestroyCurrentMessageLoop());
 
+  // OK, now make it so that no one can find us.
+  tls_index_.Set(NULL);
+
   DCHECK(!state_);
 
-  // Clean up any unprocessed tasks, but take care: deleting a task could
-  // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
-  // limit on the number of times we will allow a deleted task to generate more
-  // tasks.  Normally, we should only pass through this loop once or twice.  If
-  // we end up hitting the loop limit, then it is probably due to one task that
-  // is being stubborn.  Inspect the queues to see who is left.
-  bool did_work;
-  for (int i = 0; i < 100; ++i) {
-    DeletePendingTasks();
-    ReloadWorkQueue();
-    // If we end up with empty queues, then break out of the loop.
-    did_work = DeletePendingTasks();
-    if (!did_work)
-      break;
-  }
-  DCHECK(!did_work);
+  // Most tasks that have not been Run() are deleted in the |timer_manager_|
+  // destructor after we remove our tls index.  We delete the tasks in our
+  // queues here so their destuction is similar to the tasks in the
+  // |timer_manager_|.
+  DeletePendingTasks();
+  ReloadWorkQueue();
+  DeletePendingTasks();
 
-  // OK, now make it so that no one can find us.
-  tls_index_.Set(NULL);
+  // Delete tasks in the delayed work queue.
+  while (!delayed_work_queue_.empty()) {
+    Task* task = delayed_work_queue_.top().task;
+    delayed_work_queue_.pop();
+    delete task;
+  }
 
 #if defined(OS_WIN)
   // Match timeBeginPeriod() from construction.
@@ -332,26 +330,20 @@ void MessageLoop::ReloadWorkQueue() {
   }
 }
 
-bool MessageLoop::DeletePendingTasks() {
-  bool did_work = !work_queue_.empty();
-  while (!work_queue_.empty()) {
-    Task* task = work_queue_.front().task;
-    work_queue_.pop();
-    delete task;
-  }
-  did_work |= !deferred_non_nestable_work_queue_.empty();
-  while (!deferred_non_nestable_work_queue_.empty()) {
-    Task* task = deferred_non_nestable_work_queue_.front().task;
-    deferred_non_nestable_work_queue_.pop();
-    delete task;
+void MessageLoop::DeletePendingTasks() {
+  /* Comment this out as it's causing crashes.
+  while (!work_queue_.Empty()) {
+    Task* task = work_queue_.Pop();
+    if (task->is_owned_by_message_loop())
+      delete task;
   }
-  did_work |= !delayed_work_queue_.empty();
-  while (!delayed_work_queue_.empty()) {
-    Task* task = delayed_work_queue_.top().task;
-    delayed_work_queue_.pop();
-    delete task;
+
+  while (!delayed_non_nestable_queue_.Empty()) {
+    Task* task = delayed_non_nestable_queue_.Pop();
+    if (task->is_owned_by_message_loop())
+      delete task;
   }
-  return did_work;
+  */
 }
 
 bool MessageLoop::DoWork() {
diff --git a/base/message_loop.h b/base/message_loop.h
index 9343c4e..53c832a 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -322,9 +322,8 @@ class MessageLoop : public base::MessagePump::Delegate {
   void ReloadWorkQueue();
 
   // Delete tasks that haven't run yet without running them.  Used in the
-  // destructor to make sure all the task's destructors get called.  Returns
-  // true if some work was done.
-  bool DeletePendingTasks();
+  // destructor to make sure all the task's destructors get called.
+  void DeletePendingTasks();
 
   // Post a task to our incomming queue.
   void PostTask_Helper(const tracked_objects::Location& from_here, Task* task,
@@ -365,7 +364,6 @@ class MessageLoop : public base::MessagePump::Delegate {
   scoped_refptr<base::MessagePump> pump_;
 
   ObserverList<DestructionObserver> destruction_observers_;
-
   // A recursion block that prevents accidentally running additonal tasks when
   // insider a (accidentally induced?) nested message pump.
   bool nestable_tasks_allowed_;
diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc
index e79c576..b36090a6d 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -290,52 +290,6 @@ void RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::Type message_loop_type)
   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) {
@@ -1095,18 +1049,6 @@ TEST(MessageLoopTest, PostDelayedTask_InPostOrder_3) {
   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);