Revert 134443 - Broke win_aura

chrome/browser/hang_monitor/hung_window_detector.cc

 // Copyright (c) 2012 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 "chrome/browser/hang_monitor/hung_window_detector.h"
+#include "chrome/common/chrome_constants.h"
 
 #include <windows.h>
 #include <atlbase.h>
 
 #include "base/logging.h"
-#include "chrome/browser/hang_monitor/hang_crash_dump_win.h"
 #include "content/public/common/result_codes.h"
 
-namespace {
-
 // How long do we wait for the terminated thread or process to die (in ms)
 static const int kTerminateTimeout = 2000;
-
-}  // namespace
+// How long do we wait for the crash to be generated (in ms).
+static const int kGenerateDumpTimeout = 10000;
 
 const wchar_t HungWindowDetector::kHungChildWindowTimeout[] =
     L"Chrome_HungChildWindowTimeout";
 
+namespace {
+
+typedef void (*DumpProcessWithoutCrashFn)();
+// This function will be called via an injected thread in the hung plugin
+// process. calling DumpProcessWithoutCrash causes breakpad to capture a dump of
+// the process.
+DWORD WINAPI HungPluginDumpAndExit(void*) {
+  typedef void (__cdecl *DumpProcessFunction)();
+  DumpProcessFunction request_dump = reinterpret_cast<DumpProcessFunction>(
+      ::GetProcAddress(::GetModuleHandle(
+                       chrome::kBrowserProcessExecutableName),
+                       "DumpProcessWithoutCrash"));
+  if (request_dump)
+    request_dump();
+  return 0;
+}
+
+}  // namespace
+
 HungWindowDetector::HungWindowDetector(HungWindowNotification* notification)
     : notification_(notification),
       top_level_window_(NULL),
       message_response_timeout_(0),
       enumerating_(false) {
   DCHECK(NULL != notification_);
 }
 // NOTE: It is the caller's responsibility to make sure that
 // callbacks on this object have been stopped before
 // destroying this object
@@ skipping 120 matching lines @@
           if (NULL == child_process.m_h)  {
             break;
           }
           // Before swinging the axe, do some sanity checks to make
           // sure this window still belongs to the same process
           DWORD process_id_check = 0;
           GetWindowThreadProcessId(child_window, &process_id_check);
           if (process_id_check !=  child_window_process_id) {
             break;
           }
-
           // Before terminating the process we try collecting a dump. Which
           // a transient thread in the child process will do for us.
-          CrashDumpAndTerminateHungChildProcess(child_process);
+          HANDLE remote_thread =
+              CreateRemoteThread(child_process,
+                                 NULL,
+                                 0,
+                                 &HungPluginDumpAndExit,
+                                 0,
+                                 0,
+                                 NULL);
+          if (remote_thread) {
+            WaitForSingleObject(remote_thread, kGenerateDumpTimeout);
+            CloseHandle(remote_thread);
+          }
+
+          TerminateProcess(child_process, content::RESULT_CODE_HUNG);
+          WaitForSingleObject(child_process, kTerminateTimeout);
           child_process.Close();
           break;
         }
         default: {
           break;
         }
       }
     } else {
       RemoveProp(child_window, kHungChildWindowTimeout);
     }
   }
 
   return continue_hang_detection;
 }
 
 BOOL CALLBACK HungWindowDetector::ChildWndEnumProc(HWND child_window,
                                                    LPARAM param) {
   HungWindowDetector* detector_instance =
       reinterpret_cast<HungWindowDetector*>(param);
   if (NULL == detector_instance) {
     NOTREACHED();
     return FALSE;
   }
 
   return detector_instance->CheckChildWindow(child_window);
 }