Added an integration test for kasko hang reports

components/browser_watcher/window_hang_monitor_win.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 "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/message_window.h"
 
 namespace browser_watcher {
 
 namespace {
 
-HWND FindNamedWindowForProcess(const base::string16 name, base::ProcessId pid) {
-  HWND candidate = base::win::MessageWindow::FindWindow(name);
-  if (candidate) {
+// Returns the class name for the |window|.
+base::string16 GetWindowClassName(HWND window) {
+  const int kClassNameLength = MAX_PATH;
+  wchar_t class_name[kClassNameLength];
+  int nb_copied = ::GetClassName(window, class_name, kClassNameLength);
+  if (nb_copied) {
+    return base::string16(class_name);
+  }
+  return base::string16();
+}
+
+// Returns the Chrome message window handle for the specified |pid| or nullptr
+// if not found.
+HWND FindChromeMessageWindow(base::ProcessId pid) {

[Sigurður Ásgeirsson, 2016/01/11 19:42:59]

now that I think about it, I'm not sure this is "good enough". The problem is
that this will find *A* message window, but I don't know that there's precisely
zero or one of those per chrome instance. The lifetime of other message windows
may or may not be appropriate for hang monitoring.

[Patrick Monette, 2016/01/20 17:21:35]

So I'm now also check that the name of the window is an existing path.

+  HWND candidate = ::FindWindowEx(HWND_MESSAGE, nullptr, nullptr, nullptr);
+  while (candidate) {
     DWORD actual_process_id = 0;
     ::GetWindowThreadProcessId(candidate, &actual_process_id);
-    if (actual_process_id == pid)
+    if (GetWindowClassName(candidate) == L"Chrome_MessageWindow" &&

[Sigurður Ásgeirsson, 2016/01/11 19:42:59]

doesn't matter a whole lot, but you can avoid a bunch of string copying here by
naming this function something like IsWindowClassName, and passing it a
stringpiece.

[Patrick Monette, 2016/01/20 17:21:35]

Done.

+        actual_process_id == pid) {
       return candidate;
+    }
+    candidate = ::GetNextWindow(candidate, GW_HWNDNEXT);
   }
   return nullptr;
 }
 
 }  // namespace
 
 WindowHangMonitor::WindowHangMonitor(base::TimeDelta ping_interval,
                                      base::TimeDelta timeout,
                                      const WindowEventCallback& callback)
     : callback_(callback),
       ping_interval_(ping_interval),
       hang_timeout_(timeout),
       timer_(false /* don't retain user task */, false /* don't repeat */),
       outstanding_ping_(nullptr) {
 }
 
 WindowHangMonitor::~WindowHangMonitor() {
   if (outstanding_ping_) {
     // We have an outstanding ping, disable it and leak it intentionally as
     // if the callback arrives eventually, it'll cause a use-after-free.
     outstanding_ping_->monitor = nullptr;
     outstanding_ping_ = nullptr;
   }
 }
 
-void WindowHangMonitor::Initialize(base::Process process,
-                                   const base::string16& window_name) {
-  window_name_ = window_name;
+void WindowHangMonitor::Initialize(base::Process process) {
   window_process_ = process.Pass();
   timer_.SetTaskRunner(base::MessageLoop::current()->task_runner());
 
   ScheduleFindWindow();
 }
 
 void WindowHangMonitor::ScheduleFindWindow() {
   // TODO(erikwright): We could reduce the polling by using WaitForInputIdle,
   // but it is hard to test (requiring a non-Console executable).
   timer_.Start(
       FROM_HERE, ping_interval_,
       base::Bind(&WindowHangMonitor::PollForWindow, base::Unretained(this)));
 }
 
 void WindowHangMonitor::PollForWindow() {
   int exit_code = 0;
   if (window_process_.WaitForExitWithTimeout(base::TimeDelta(), &exit_code)) {
     callback_.Run(WINDOW_NOT_FOUND);
     return;
   }
 
-  HWND hwnd = FindNamedWindowForProcess(window_name_, window_process_.Pid());
+  HWND hwnd = FindChromeMessageWindow(window_process_.Pid());
   if (hwnd) {
     // Sends a ping and schedules a timeout task. Upon receiving a ping response
     // further pings will be scheduled ad infinitum. Will signal any failure now
     // or later via the callback.
     SendPing(hwnd);
   } else {
     ScheduleFindWindow();
   }
 }
 
@@ skipping 39 matching lines @@
 void WindowHangMonitor::OnHangTimeout(HWND hwnd) {
   DCHECK(window_process_.IsValid());
 
   if (outstanding_ping_) {
     // The ping is still outstanding, the window is hung or has vanished.
     // Orphan the outstanding ping. If the callback arrives late, it will
     // delete it, or if the callback never arrives it'll leak.
     outstanding_ping_->monitor = NULL;
     outstanding_ping_ = NULL;
 
-    if (hwnd !=
-        FindNamedWindowForProcess(window_name_, window_process_.Pid())) {
+    if (hwnd != FindChromeMessageWindow(window_process_.Pid())) {
       // The window vanished.
       callback_.Run(WINDOW_VANISHED);
     } else {
       // The window hung.
       callback_.Run(WINDOW_HUNG);
     }
   } else {
     // No ping outstanding, window is not yet hung. Schedule the next retry.
     timer_.Start(
         FROM_HERE, hang_timeout_ - ping_interval_,
         base::Bind(&WindowHangMonitor::OnRetryTimeout, base::Unretained(this)));
   }
 }
 
 void WindowHangMonitor::OnRetryTimeout() {
   DCHECK(window_process_.IsValid());
   DCHECK(!outstanding_ping_);
   // We can't simply hold onto the previously located HWND due to potential
   // aliasing.
   // 1. The window handle might have been re-assigned to a different window
   //    from the time we found it to the point where we query for its owning
   //    process.
   // 2. The window handle might have been re-assigned to a different process
   //    at any point after we found it.
-  HWND hwnd = FindNamedWindowForProcess(window_name_, window_process_.Pid());
+  HWND hwnd = FindChromeMessageWindow(window_process_.Pid());
   if (hwnd)
     SendPing(hwnd);
   else
     callback_.Run(WINDOW_VANISHED);
 }
 
 }  // namespace browser_watcher