Kill CleanUpAfterMessageLoopDestruction.

base/threading/thread_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/threading/thread.h"
 
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
@@ skipping 39 matching lines @@
     base::PlatformThread::Sleep(500);
     init_called_ = true;
   }
   bool InitCalled() { return init_called_; }
  private:
   bool init_called_;
 };
 
 enum ThreadEvent {
   // Thread::Init() was called.
-  THREAD_EVENT_INIT,
+  THREAD_EVENT_INIT = 0,
 
   // The MessageLoop for the thread was deleted.
   THREAD_EVENT_MESSAGE_LOOP_DESTROYED,
 
   // Thread::CleanUp() was called.
   THREAD_EVENT_CLEANUP,
 
-  // Thread::CleanUpAfterMessageLoopDestruction() was called.
-  THREAD_EVENT_CLEANUP_AFTER_LOOP,
+  // Keep at end of list.
+  THREAD_NUM_EVENTS
 };
 
 typedef std::vector<ThreadEvent> EventList;
 
 class CaptureToEventList : public Thread {
  public:
   // This Thread pushes events into the vector |event_list| to show
   // the order they occured in. |event_list| must remain valid for the
   // lifetime of this thread.
   explicit CaptureToEventList(EventList* event_list)
       : Thread("none"), event_list_(event_list) {
   }
 
   virtual ~CaptureToEventList() {
     // Must call Stop() manually to have our CleanUp() function called.
     Stop();
   }
 
   virtual void Init() {
     event_list_->push_back(THREAD_EVENT_INIT);
   }
 
   virtual void CleanUp() {
     event_list_->push_back(THREAD_EVENT_CLEANUP);
   }
 
-  virtual void CleanUpAfterMessageLoopDestruction() {
-    event_list_->push_back(THREAD_EVENT_CLEANUP_AFTER_LOOP);
-  }
-
  private:
   EventList* event_list_;
 };
 
 // Observer that writes a value into |event_list| when a message loop has been
 // destroyed.
 class CapturingDestructionObserver : public MessageLoop::DestructionObserver {
  public:
   // |event_list| must remain valid throughout the observer's lifetime.
   explicit CapturingDestructionObserver(EventList* event_list)
@@ skipping 113 matching lines @@
   EXPECT_FALSE(t.InitCalled());
   t.Start();
   EXPECT_TRUE(t.InitCalled());
 }
 
 // Make sure that the destruction sequence is:
 //
 //  (1) Thread::CleanUp()
 //  (2) MessageLoop::~MessageLoop()
 //      MessageLoop::DestructionObservers called.
-//  (3) Thread::CleanUpAfterMessageLoopDestruction
 TEST_F(ThreadTest, CleanUp) {
   EventList captured_events;
   CapturingDestructionObserver loop_destruction_observer(&captured_events);
 
   {
     // Start a thread which writes its event into |captured_events|.
     CaptureToEventList t(&captured_events);
     EXPECT_TRUE(t.Start());
     EXPECT_TRUE(t.message_loop());
     EXPECT_TRUE(t.IsRunning());
 
     // Register an observer that writes into |captured_events| once the
     // thread's message loop is destroyed.
     t.message_loop()->PostTask(
         FROM_HERE,
         new RegisterDestructionObserver(&loop_destruction_observer));
 
     // Upon leaving this scope, the thread is deleted.
   }
 
   // Check the order of events during shutdown.
-  ASSERT_EQ(4u, captured_events.size());
+  ASSERT_EQ(static_cast<size_t>(THREAD_NUM_EVENTS), captured_events.size());
   EXPECT_EQ(THREAD_EVENT_INIT, captured_events[0]);
   EXPECT_EQ(THREAD_EVENT_CLEANUP, captured_events[1]);
   EXPECT_EQ(THREAD_EVENT_MESSAGE_LOOP_DESTROYED, captured_events[2]);
-  EXPECT_EQ(THREAD_EVENT_CLEANUP_AFTER_LOOP, captured_events[3]);
 }