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/files/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/strings/string16.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 {
+
+const base::char16 kRegistryPath[] = L"Software\\HangMonitorTest";
+
+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 {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    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), temp_dir_.path().value(), &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));
+  }
+
+  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_; }
+  base::Thread* worker_thread() { return &worker_thread_; }
+  const base::ScopedTempDir& temp_dir() const { return temp_dir_; }

[erikwright (departed), 2015/03/25 18:57:22]

this is just used to get a unique string, right?

How about just concatenating the current process PID with a prefix like
"window_hang_monitor_test_"?

Less obscure, and leaves less crud around if the test dies somehow.

[Sigurður Ásgeirsson, 2015/03/25 19:56:53]

Done.

+
+ 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_;
+  size_t pings_;
+  base::Thread worker_thread_;
+  base::ScopedTempDir temp_dir_;
+};
+
+}  // namespace
+
+TEST_F(WindowHangMonitorTest, InitFailsWhenNoWindow) {
+  ASSERT_FALSE(monitor()->Initialize(temp_dir().path().value()));
+  EXPECT_TRUE(monitor()->IsIdleForTesting());
+  EXPECT_EQ(0, pings());
+  EXPECT_EQ(0, events().size());
+}
+
+TEST_F(WindowHangMonitorTest, InitSucceedsWhenWindow) {
+  CreateMessageWindow();
+
+  ASSERT_TRUE(monitor()->Initialize(temp_dir().path().value()));
+  EXPECT_FALSE(monitor()->IsIdleForTesting());
+
+  EXPECT_EQ(1, pings());
+  EXPECT_EQ(0, events().size());
+}
+
+TEST_F(WindowHangMonitorTest, DetectsWindowDisappearance) {
+  CreateMessageWindow();
+
+  EXPECT_TRUE(monitor()->Initialize(temp_dir().path().value()));
+  EXPECT_EQ(1, pings());
+  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(temp_dir().path().value()));
+  EXPECT_EQ(1, pings());
+  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(temp_dir().path().value()));
+  EXPECT_EQ(1, pings());
+  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