Random bits of header and whitespace cleanup.

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 <vector>
+
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
@@ skipping 817 matching lines @@
 
     // Poll for the MessageBox. Don't do this at home! At the speed we do it,
     // you will never realize one MessageBox was shown.
     for (; expect_window_;) {
       HWND window = FindWindow(L"#32770", kMessageBoxTitle);
       if (window) {
         // Dismiss it.
         for (;;) {
           HWND button = FindWindowEx(window, NULL, L"Button", NULL);
           if (button != NULL) {
-            EXPECT_TRUE(0 == SendMessage(button, WM_LBUTTONDOWN, 0, 0));
-            EXPECT_TRUE(0 == SendMessage(button, WM_LBUTTONUP, 0, 0));
+            EXPECT_EQ(0, SendMessage(button, WM_LBUTTONDOWN, 0, 0));
+            EXPECT_EQ(0, SendMessage(button, WM_LBUTTONUP, 0, 0));
             break;
           }
         }
         break;
       }
     }
   }
 
  private:
   MessageLoop* target_;
@@ skipping 598 matching lines @@
 }
 
 TEST(MessageLoopTest, NonNestableDelayedInNestedLoop) {
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT, true);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, true);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, true);
 }
 
 class DummyTask : public Task {
  public:
-  DummyTask(int num_tasks) : num_tasks_(num_tasks) {}
+  explicit DummyTask(int num_tasks) : num_tasks_(num_tasks) {}
 
   virtual void Run() {
     if (num_tasks_ > 1) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           new DummyTask(num_tasks_ - 1));
     } else {
       MessageLoop::current()->Quit();
     }
   }
 
  private:
   const int num_tasks_;
 };
 
 class DummyTaskObserver : public MessageLoop::TaskObserver {
  public:
-  DummyTaskObserver(int num_tasks)
+  explicit DummyTaskObserver(int num_tasks)
       : num_tasks_started_(0),
         num_tasks_processed_(0),
         num_tasks_(num_tasks) {}
 
   virtual ~DummyTaskObserver() {}
 
   virtual void WillProcessTask(base::TimeTicks /* birth_time */) {
     num_tasks_started_++;
     EXPECT_LE(num_tasks_started_, num_tasks_);
     EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1);
@@ skipping 95 matching lines @@
 
 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_TRUE(err == 0);
+  ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // Arrange for controller to live longer than message loop.
     base::MessagePumpLibevent::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_TRUE(err == 0);
+  ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // Arrange for message loop to live longer than controller.
     MessageLoopForIO message_loop;
     {
       base::MessagePumpLibevent::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)
     PLOG(ERROR) << "close";
 }
 
 }  // namespace
 
 #endif  // defined(OS_POSIX)