Move base to DEPS

base/message_loop/message_pump_libevent_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_pump_libevent.h"
-
-#include <unistd.h>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file_util.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/synchronization/waitable_event_watcher.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/libevent/event.h"
-
-namespace base {
-
-class MessagePumpLibeventTest : public testing::Test {
- protected:
-  MessagePumpLibeventTest()
-      : ui_loop_(new MessageLoop(MessageLoop::TYPE_UI)),
-        io_thread_("MessagePumpLibeventTestIOThread") {}
-  ~MessagePumpLibeventTest() override {}
-
-  void SetUp() override {
-    Thread::Options options(MessageLoop::TYPE_IO, 0);
-    ASSERT_TRUE(io_thread_.StartWithOptions(options));
-    ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type());
-    int ret = pipe(pipefds_);
-    ASSERT_EQ(0, ret);
-  }
-
-  void TearDown() override {
-    if (IGNORE_EINTR(close(pipefds_[0])) < 0)
-      PLOG(ERROR) << "close";
-    if (IGNORE_EINTR(close(pipefds_[1])) < 0)
-      PLOG(ERROR) << "close";
-  }
-
-  MessageLoopForIO* io_loop() const {
-    return static_cast<MessageLoopForIO*>(io_thread_.message_loop());
-  }
-
-  void OnLibeventNotification(
-      MessagePumpLibevent* pump,
-      MessagePumpLibevent::FileDescriptorWatcher* controller) {
-    pump->OnLibeventNotification(0, EV_WRITE | EV_READ, controller);
-  }
-
-  int pipefds_[2];
-  scoped_ptr<MessageLoop> ui_loop_;
-
- private:
-  Thread io_thread_;
-};
-
-namespace {
-
-// Concrete implementation of MessagePumpLibevent::Watcher that does
-// nothing useful.
-class StupidWatcher : public MessagePumpLibevent::Watcher {
- public:
-  ~StupidWatcher() override {}
-
-  // base:MessagePumpLibevent::Watcher interface
-  void OnFileCanReadWithoutBlocking(int fd) override {}
-  void OnFileCanWriteWithoutBlocking(int fd) override {}
-};
-
-#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-
-// Test to make sure that we catch calling WatchFileDescriptor off of the
-// wrong thread.
-#if defined(OS_CHROMEOS) || defined(OS_LINUX)
-// Flaky on Chrome OS and Linux: crbug.com/138845.
-#define MAYBE_TestWatchingFromBadThread DISABLED_TestWatchingFromBadThread
-#else
-#define MAYBE_TestWatchingFromBadThread TestWatchingFromBadThread
-#endif
-TEST_F(MessagePumpLibeventTest, MAYBE_TestWatchingFromBadThread) {
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
-  StupidWatcher delegate;
-
-  ASSERT_DEATH(io_loop()->WatchFileDescriptor(
-      STDOUT_FILENO, false, MessageLoopForIO::WATCH_READ, &watcher, &delegate),
-      "Check failed: "
-      "watch_file_descriptor_caller_checker_.CalledOnValidThread\\(\\)");
-}
-
-TEST_F(MessagePumpLibeventTest, QuitOutsideOfRun) {
-  scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  ASSERT_DEATH(pump->Quit(), "Check failed: in_run_. "
-                             "Quit was called outside of Run!");
-}
-
-#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-
-class BaseWatcher : public MessagePumpLibevent::Watcher {
- public:
-  explicit BaseWatcher(MessagePumpLibevent::FileDescriptorWatcher* controller)
-      : controller_(controller) {
-    DCHECK(controller_);
-  }
-  ~BaseWatcher() override {}
-
-  // base:MessagePumpLibevent::Watcher interface
-  void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
-  void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
- protected:
-  MessagePumpLibevent::FileDescriptorWatcher* controller_;
-};
-
-class DeleteWatcher : public BaseWatcher {
- public:
-  explicit DeleteWatcher(
-      MessagePumpLibevent::FileDescriptorWatcher* controller)
-      : BaseWatcher(controller) {}
-
-  ~DeleteWatcher() override { DCHECK(!controller_); }
-
-  void OnFileCanWriteWithoutBlocking(int /* fd */) override {
-    DCHECK(controller_);
-    delete controller_;
-    controller_ = NULL;
-  }
-};
-
-TEST_F(MessagePumpLibeventTest, DeleteWatcher) {
-  scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  MessagePumpLibevent::FileDescriptorWatcher* watcher =
-      new MessagePumpLibevent::FileDescriptorWatcher;
-  DeleteWatcher delegate(watcher);
-  pump->WatchFileDescriptor(pipefds_[1],
-      false, MessagePumpLibevent::WATCH_READ_WRITE, watcher, &delegate);
-
-  // Spoof a libevent notification.
-  OnLibeventNotification(pump.get(), watcher);
-}
-
-class StopWatcher : public BaseWatcher {
- public:
-  explicit StopWatcher(
-      MessagePumpLibevent::FileDescriptorWatcher* controller)
-      : BaseWatcher(controller) {}
-
-  ~StopWatcher() override {}
-
-  void OnFileCanWriteWithoutBlocking(int /* fd */) override {
-    controller_->StopWatchingFileDescriptor();
-  }
-};
-
-TEST_F(MessagePumpLibeventTest, StopWatcher) {
-  scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
-  StopWatcher delegate(&watcher);
-  pump->WatchFileDescriptor(pipefds_[1],
-      false, MessagePumpLibevent::WATCH_READ_WRITE, &watcher, &delegate);
-
-  // Spoof a libevent notification.
-  OnLibeventNotification(pump.get(), &watcher);
-}
-
-void QuitMessageLoopAndStart(const Closure& quit_closure) {
-  quit_closure.Run();
-
-  MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
-  RunLoop runloop;
-  MessageLoop::current()->PostTask(FROM_HERE, runloop.QuitClosure());
-  runloop.Run();
-}
-
-class NestedPumpWatcher : public MessagePumpLibevent::Watcher {
- public:
-  NestedPumpWatcher() {}
-  ~NestedPumpWatcher() override {}
-
-  void OnFileCanReadWithoutBlocking(int /* fd */) override {
-    RunLoop runloop;
-    MessageLoop::current()->PostTask(FROM_HERE, Bind(&QuitMessageLoopAndStart,
-                                                     runloop.QuitClosure()));
-    runloop.Run();
-  }
-
-  void OnFileCanWriteWithoutBlocking(int /* fd */) override {}
-};
-
-TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) {
-  scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
-  MessagePumpLibevent::FileDescriptorWatcher watcher;
-  NestedPumpWatcher delegate;
-  pump->WatchFileDescriptor(pipefds_[1],
-      false, MessagePumpLibevent::WATCH_READ, &watcher, &delegate);
-
-  // Spoof a libevent notification.
-  OnLibeventNotification(pump.get(), &watcher);
-}
-
-void FatalClosure() {
-  FAIL() << "Reached fatal closure.";
-}
-
-class QuitWatcher : public BaseWatcher {
- public:
-  QuitWatcher(MessagePumpLibevent::FileDescriptorWatcher* controller,
-              RunLoop* run_loop)
-      : BaseWatcher(controller), run_loop_(run_loop) {}
-  ~QuitWatcher() override {}
-
-  void OnFileCanReadWithoutBlocking(int /* fd */) override {
-    // Post a fatal closure to the MessageLoop before we quit it.
-    MessageLoop::current()->PostTask(FROM_HERE, Bind(&FatalClosure));
-
-    // Now quit the MessageLoop.
-    run_loop_->Quit();
-  }
-
- private:
-  RunLoop* run_loop_;  // weak
-};
-
-void WriteFDWrapper(const int fd,
-                    const char* buf,
-                    int size,
-                    WaitableEvent* event) {
-  ASSERT_TRUE(WriteFileDescriptor(fd, buf, size));
-}
-
-// Tests that MessagePumpLibevent quits immediately when it is quit from
-// libevent's event_base_loop().
-TEST_F(MessagePumpLibeventTest, QuitWatcher) {
-  // Delete the old MessageLoop so that we can manage our own one here.
-  ui_loop_.reset();
-
-  MessagePumpLibevent* pump = new MessagePumpLibevent;  // owned by |loop|.
-  MessageLoop loop(make_scoped_ptr(pump));
-  RunLoop run_loop;
-  MessagePumpLibevent::FileDescriptorWatcher controller;
-  QuitWatcher delegate(&controller, &run_loop);
-  WaitableEvent event(false /* manual_reset */, false /* initially_signaled */);
-  scoped_ptr<WaitableEventWatcher> watcher(new WaitableEventWatcher);
-
-  // Tell the pump to watch the pipe.
-  pump->WatchFileDescriptor(pipefds_[0], false, MessagePumpLibevent::WATCH_READ,
-                            &controller, &delegate);
-
-  // Make the IO thread wait for |event| before writing to pipefds[1].
-  const char buf = 0;
-  const WaitableEventWatcher::EventCallback write_fd_task =
-      Bind(&WriteFDWrapper, pipefds_[1], &buf, 1);
-  io_loop()->PostTask(FROM_HERE,
-                      Bind(IgnoreResult(&WaitableEventWatcher::StartWatching),
-                           Unretained(watcher.get()), &event, write_fd_task));
-
-  // Queue |event| to signal on |loop|.
-  loop.PostTask(FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&event)));
-
-  // Now run the MessageLoop.
-  run_loop.Run();
-
-  // StartWatching can move |watcher| to IO thread. Release on IO thread.
-  io_loop()->PostTask(FROM_HERE, Bind(&WaitableEventWatcher::StopWatching,
-                                      Owned(watcher.release())));
-}
-
-}  // namespace
-
-}  // namespace base