Implements a monitor to watch for the browser hanging.

components/browser_watcher/window_hang_monitor_win_unittest.cc

+// Copyright 2015 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 "components/browser_watcher/window_hang_monitor_win.h"
+
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/process/process_handle.h"
+#include "base/run_loop.h"
+#include "base/strings/string16.h"
+#include "base/strings/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "base/win/message_window.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace browser_watcher {
+
+namespace {
+
+class WindowHangMonitorTest : public testing::Test {
+ public:
+  typedef std::vector<WindowHangMonitor::WindowEvent> WindowEventVector;
+
+  WindowHangMonitorTest()
+      : monitor_(base::Bind(&WindowHangMonitorTest::OnWindowEvent,
+                            base::Unretained(this))),
+        message_loop_(base::MessageLoop::TYPE_UI),
+        run_loop_(nullptr),
+        pings_(0),
+        worker_thread_("HangMan") {}
+
+  // Callback from the hang detector.
+  void OnWindowEvent(WindowHangMonitor::WindowEvent event) {
+    // Record the event and terminate the message loop.
+    events_.push_back(event);
+    run_loop_->Quit();
+  }
+
+  void SetUp() override {
+    // Pick a window name unique to this process.
+    window_name_ = base::StringPrintf(L"WindowHanMonitorTest-%d",
+                                      base::GetCurrentProcId());
+    ASSERT_TRUE(worker_thread_.StartWithOptions(
+        base::Thread::Options(base::MessageLoop::TYPE_UI, 0)));
+
+    // Set relatively short hang detection and ping intervals.
+    monitor_.SetHangTimeoutForTesting(base::TimeDelta::FromMilliseconds(50));
+    monitor_.SetPingIntervalForTesting(base::TimeDelta::FromMilliseconds(200));
+  }
+
+  void TearDown() override {
+    DeleteMessageWindow();
+    worker_thread_.Stop();
+  }
+
+  void CreateMessageWindow() {
+    bool succeeded = false;
+    base::WaitableEvent created(true, false);
+    ASSERT_TRUE(worker_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&WindowHangMonitorTest::CreateMessageWindowInWorkerThread,
+                   base::Unretained(this), window_name_, &succeeded,
+                   &created)));
+    created.Wait();
+    ASSERT_TRUE(succeeded);
+  }
+
+  void DeleteMessageWindow() {
+    base::WaitableEvent deleted(true, false);
+    worker_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&WindowHangMonitorTest::DeleteMessageWindowInWorkerThread,
+                   base::Unretained(this), &deleted));
+    deleted.Wait();
+  }
+
+  bool MessageCallback(UINT message,
+                       WPARAM wparam,
+                       LPARAM lparam,
+                       LRESULT* result) {
+    EXPECT_EQ(worker_thread_.message_loop(), base::MessageLoop::current());
+    if (message == WM_NULL)
+      ++pings_;
+
+    return false;  // Pass through to DefWindowProc.
+  }
+
+  void RunMessageLoop() {
+    ASSERT_FALSE(run_loop_);
+
+    base::RunLoop loop;
+
+    run_loop_ = &loop;
+    loop.Run();
+    run_loop_ = nullptr;
+  }
+
+  WindowHangMonitor* monitor() { return &monitor_; }
+  const WindowEventVector& events() const { return events_; }
+  const base::win::MessageWindow* message_window() const {
+    return message_window_.get();
+  }
+  size_t pings() const { return pings_; }
+  const base::string16& window_name() const { return window_name_; }
+  base::Thread* worker_thread() { return &worker_thread_; }
+
+ private:
+  void CreateMessageWindowInWorkerThread(const base::string16& name,
+                                         bool* success,
+                                         base::WaitableEvent* created) {
+    message_window_.reset(new base::win::MessageWindow);
+    *success = message_window_->CreateNamed(
+        base::Bind(&WindowHangMonitorTest::MessageCallback,
+                   base::Unretained(this)),
+        name);
+    created->Signal();
+  }
+
+  void DeleteMessageWindowInWorkerThread(base::WaitableEvent* deleted) {
+    message_window_.reset();
+    if (deleted)
+      deleted->Signal();
+  }
+
+  WindowHangMonitor monitor_;
+  WindowEventVector events_;
+
+  // Message and run loops for the main thread.
+  base::MessageLoop message_loop_;
+  base::RunLoop* run_loop_;
+  scoped_ptr<base::win::MessageWindow> message_window_;
+  base::string16 window_name_;
+  size_t pings_;
+  base::Thread worker_thread_;
+};
+
+}  // namespace
+
+TEST_F(WindowHangMonitorTest, InitFailsWhenNoWindow) {
+  ASSERT_FALSE(monitor()->Initialize(window_name()));
+  EXPECT_TRUE(monitor()->IsIdleForTesting());
+  EXPECT_EQ(0, pings());
+  EXPECT_EQ(0, events().size());
+}
+
+TEST_F(WindowHangMonitorTest, InitSucceedsWhenWindow) {
+  CreateMessageWindow();
+
+  ASSERT_TRUE(monitor()->Initialize(window_name()));
+  EXPECT_FALSE(monitor()->IsIdleForTesting());
+
+  // Delete the window to synchronize against any pending message pings.
+  DeleteMessageWindow();
+
+  EXPECT_EQ(1, pings());
+  EXPECT_EQ(0, events().size());
+}
+
+TEST_F(WindowHangMonitorTest, DetectsWindowDisappearance) {
+  CreateMessageWindow();
+
+  EXPECT_TRUE(monitor()->Initialize(window_name()));
+  EXPECT_EQ(0, events().size());
+
+  DeleteMessageWindow();
+
+  RunMessageLoop();
+
+  EXPECT_TRUE(monitor()->IsIdleForTesting());
+  ASSERT_EQ(1, events().size());
+  EXPECT_EQ(WindowHangMonitor::WINDOW_VANISHED, events()[0]);
+}
+
+TEST_F(WindowHangMonitorTest, DetectsWindowNameChange) {
+  // This test changes the title of the message window as a proxy for what
+  // happens if the window handle is reused for a different purpose. The latter
+  // is impossible to test in a deterministic fashion.
+  CreateMessageWindow();
+
+  ASSERT_TRUE(monitor()->Initialize(window_name()));
+  EXPECT_EQ(0, events().size());
+
+  ASSERT_TRUE(::SetWindowText(message_window()->hwnd(), L"Gonsky"));
+
+  RunMessageLoop();
+
+  EXPECT_TRUE(monitor()->IsIdleForTesting());
+  ASSERT_EQ(1, events().size());
+  EXPECT_EQ(WindowHangMonitor::WINDOW_VANISHED, events()[0]);
+}
+
+TEST_F(WindowHangMonitorTest, DetectsWindowHang) {
+  CreateMessageWindow();
+
+  ASSERT_TRUE(monitor()->Initialize(window_name()));
+  EXPECT_EQ(0, events().size());
+
+  // Block the worker thread.
+  base::WaitableEvent hang(true, false);
+
+  worker_thread()->message_loop_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&base::WaitableEvent::Wait, base::Unretained(&hang)));
+
+  RunMessageLoop();
+
+  // Unblock the worker thread.
+  hang.Signal();
+
+  EXPECT_TRUE(monitor()->IsIdleForTesting());
+  ASSERT_EQ(1, events().size());
+  EXPECT_EQ(WindowHangMonitor::WINDOW_HUNG, events()[0]);
+}
+
+}  // namespace browser_watcher