net doesn't depend on libevent directly now.

base/message_loop_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_pump_win.h"
 #include "base/win/scoped_handle.h"
 #endif
-#if defined(OS_POSIX)
-#include "base/message_pump_libevent.h"
-#endif
 
 using base::PlatformThread;
 using base::Thread;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
 // to avoid chopping this file up with so many #ifdefs.
 
@@ skipping 1517 matching lines @@
   loop.Run();
   EXPECT_FALSE(loop.high_resolution_timers_enabled());
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 
 namespace {
 
-class QuitDelegate : public base::MessagePumpLibevent::Watcher {
+class QuitDelegate : public MessageLoopForIO::Watcher {
  public:
   virtual void OnFileCanWriteWithoutBlocking(int fd) {
     MessageLoop::current()->Quit();
   }
   virtual void OnFileCanReadWithoutBlocking(int fd) {
     MessageLoop::current()->Quit();
   }
 };
 
 TEST(MessageLoopTest, FileDescriptorWatcherOutlivesMessageLoop) {
   // Simulate a MessageLoop that dies before an FileDescriptorWatcher.
   // This could happen when people use the Singleton pattern or atexit.
 
   // Create a file descriptor.  Doesn't need to be readable or writable,
   // as we don't need to actually get any notifications.
   // pipe() is just the easiest way to do it.
   int pipefds[2];
   int err = pipe(pipefds);
   ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // Arrange for controller to live longer than message loop.
-    base::MessagePumpLibevent::FileDescriptorWatcher controller;
+    MessageLoopForIO::FileDescriptorWatcher controller;
     {
       MessageLoopForIO message_loop;
 
       QuitDelegate delegate;
       message_loop.WatchFileDescriptor(fd,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       // and don't run the message loop, just destroy it.
     }
   }
   if (HANDLE_EINTR(close(pipefds[0])) < 0)
     PLOG(ERROR) << "close";
   if (HANDLE_EINTR(close(pipefds[1])) < 0)
     PLOG(ERROR) << "close";
 }
 
 TEST(MessageLoopTest, FileDescriptorWatcherDoubleStop) {
   // Verify that it's ok to call StopWatchingFileDescriptor().
   // (Errors only showed up in valgrind.)
   int pipefds[2];
   int err = pipe(pipefds);
   ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // Arrange for message loop to live longer than controller.
     MessageLoopForIO message_loop;
     {
-      base::MessagePumpLibevent::FileDescriptorWatcher controller;
+      MessageLoopForIO::FileDescriptorWatcher controller;
 
       QuitDelegate delegate;
       message_loop.WatchFileDescriptor(fd,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       controller.StopWatchingFileDescriptor();
     }
   }
   if (HANDLE_EINTR(close(pipefds[0])) < 0)
     PLOG(ERROR) << "close";
   if (HANDLE_EINTR(close(pipefds[1])) < 0)
@@ skipping 67 matching lines @@
       base::Bind(&DestructionObserverProbe::Run,
                  new DestructionObserverProbe(&task_destroyed,
                                               &destruction_observer_called)),
       kDelayMS);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }