Jankometer: Generalize the code more. Add better support for monitoring IO thread.

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 "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)
 #include "base/message_pump_win.h"
 #include "base/scoped_handle.h"
 #endif
 #if defined(OS_POSIX)
 #include "base/message_pump_libevent.h"
 #endif
@@ skipping 1429 matching lines @@
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, false);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, false);
 }
 
 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) {}
+
+  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)
+      : 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);
+  }
+
+  virtual void DidProcessTask() {
+    num_tasks_processed_++;
+    EXPECT_LE(num_tasks_started_, num_tasks_);
+    EXPECT_EQ(num_tasks_started_, num_tasks_processed_);
+  }
+
+  int num_tasks_started() const { return num_tasks_started_; }
+  int num_tasks_processed() const { return num_tasks_processed_; }
+
+ private:
+  int num_tasks_started_;
+  int num_tasks_processed_;
+  const int num_tasks_;
+
+  DISALLOW_COPY_AND_ASSIGN(DummyTaskObserver);
+};
+
+TEST(MessageLoopTest, TaskObserver) {
+  const int kNumTasks = 6;
+  DummyTaskObserver observer(kNumTasks);
+
+  MessageLoop loop;
+  loop.AddTaskObserver(&observer);
+  loop.PostTask(FROM_HERE, new DummyTask(kNumTasks));
+  loop.Run();
+  loop.RemoveTaskObserver(&observer);
+
+  EXPECT_EQ(kNumTasks, observer.num_tasks_started());
+  EXPECT_EQ(kNumTasks, observer.num_tasks_processed());
+}
+
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 
 TEST(MessageLoopTest, DispatcherWithMessageHook) {
   // This test requires a UI loop
   RunTest_DispatcherWithMessageHook(MessageLoop::TYPE_UI);
 }
 
 TEST(MessageLoopTest, IOHandler) {
   RunTest_IOHandler();
 }
 
 TEST(MessageLoopTest, WaitForIO) {
   RunTest_WaitForIO();
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 namespace {
 
-class QuitDelegate : public
-    base::MessagePumpLibevent::Watcher {
+class QuitDelegate : public base::MessagePumpLibevent::Watcher {
  public:
   virtual void OnFileCanWriteWithoutBlocking(int fd) {
     MessageLoop::current()->Quit();
   }
   virtual void OnFileCanReadWithoutBlocking(int fd) {
     MessageLoop::current()->Quit();
   }
 };
 
-}  // namespace
-
 TEST(MessageLoopTest, FileDescriptorWatcherOutlivesMessageLoop) {
   // Simulate a MessageLoop that dies before an FileDescriptorWatcher.
   // This could happen when people use the Singleton pattern or atexit.
   // This is disabled for now because it fails (valgrind shows
   // invalid reads), and it's not clear any code relies on this...
 
   // 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);
   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.
     }
   }
-  close(pipefds[0]);
-  close(pipefds[1]);
+  HANDLE_EINTR(close(pipefds[0]));
+  HANDLE_EINTR(close(pipefds[1]));
 }
 
 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);
   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();
     }
   }
-  close(pipefds[0]);
-  close(pipefds[1]);
+  HANDLE_EINTR(close(pipefds[0]));
+  HANDLE_EINTR(close(pipefds[1]));
 }
 
+}  // namespace
+
 #endif  // defined(OS_POSIX)