Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1109)

Unified Diff: components/browser_watcher/window_hang_monitor_win_unittest.cc

Issue 1036623002: Implements a monitor to watch for the browser hanging. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Finish testing, simplify callback. Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: components/browser_watcher/window_hang_monitor_win_unittest.cc
diff --git a/components/browser_watcher/window_hang_monitor_win_unittest.cc b/components/browser_watcher/window_hang_monitor_win_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4bb10a6337cfe540e82a5c8604303f53f04cc3fa
--- /dev/null
+++ b/components/browser_watcher/window_hang_monitor_win_unittest.cc
@@ -0,0 +1,219 @@
+// 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?
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

Powered by Google App Engine
This is Rietveld 408576698