Enable handle tracing in Canary, Dev, and all debug builds of Chrome (Windows only).

chrome/app/breakpad_win.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/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 #include <userenv.h>
+#include <winternl.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 118 matching lines @@
 // of pepper/renderer processes is reduced.
 DWORD WINAPI DumpForHangDebuggingThread(void*) {
   DumpProcessWithoutCrash();
   LOG(INFO) << "dumped for hang debugging";
   return 0;
 }
 
 MSVC_POP_WARNING()
 MSVC_ENABLE_OPTIMIZE()
 
+// Enables tracing of all operations on kernel handles.
+void EnableHandleTracing() {
+  typedef NTSTATUS (WINAPI *NtSetInformationProcessFn)(
+      HANDLE ProcessHandle,
+      ULONG ProcessInformationClass,
+      PVOID ProcessInformation,
+      ULONG ProcessInformationLength);
+
+  typedef struct _PROCESS_HANDLE_TRACING_ENABLE_EX {
+    ULONG Flags;
+    ULONG TotalSlots;
+  } PROCESS_HANDLE_TRACING_ENABLE_EX, *PPROCESS_HANDLE_TRACING_ENABLE_EX;
+
+  const ULONG kProcessHandleTracing = 0x20;
+
+  NtSetInformationProcessFn set_information_process =
+    reinterpret_cast<NtSetInformationProcessFn>(
+        GetProcAddress(GetModuleHandle(L"ntdll.dll"),
+                                       "NtSetInformationProcess"));
+
+  // Enable handle tracing. It is OK to ignore the returned error code since
+  // failing ot enable handle tracing is debug-only facility and should not
+  // affect other functionality.
+  if (set_information_process != NULL) {
+    PROCESS_HANDLE_TRACING_ENABLE_EX info = { 0, 0x20000 };
+    set_information_process(GetCurrentProcess(), kProcessHandleTracing, &info,
+                            sizeof(info));
+  }
+}
+
 // Injects a thread into a remote process to dump state when there is no crash.
 extern "C" HANDLE __declspec(dllexport) __cdecl
 InjectDumpProcessWithoutCrash(HANDLE process) {
   return CreateRemoteThread(process, NULL, 0, DumpProcessWithoutCrashThread,
                             0, 0, NULL);
 }
 
 extern "C" HANDLE __declspec(dllexport) __cdecl
 InjectDumpForHangDebugging(HANDLE process) {
   return CreateRemoteThread(process, NULL, 0, DumpForHangDebuggingThread,
@@ skipping 745 matching lines @@
   // are different because the message struct contains a pointer.  As
   // a result, there are two different named pipes to connect to.  The
   // 64-bit one is distinguished with an "-x64" suffix.
   pipe_name += L"-x64";
 #endif
 
   // Get the alternate dump directory. We use the temp path.
   wchar_t temp_dir[MAX_PATH] = {0};
   ::GetTempPathW(MAX_PATH, temp_dir);
 
+  // Do not enable handle tracing (and do not generate STATUS_INVALID_HANDLE
+  // exceptions when using an invalid handle) by default.
+  bool enable_handle_tracing = false;
+
   MINIDUMP_TYPE dump_type = kSmallDumpType;
   // Capture full memory if explicitly instructed to.
   if (command.HasSwitch(switches::kFullMemoryCrashReport)) {
     dump_type = kFullDumpType;
+    enable_handle_tracing = true;
   } else {
     std::wstring channel_name(
         GoogleUpdateSettings::GetChromeChannel(!is_per_user_install));
 
-    // Capture more detail in crash dumps for beta and dev channel builds.
-    if (channel_name == L"dev" || channel_name == L"beta" ||
-        channel_name == GoogleChromeSxSDistribution::ChannelName())
+    // Enable handle tracing and capture more detail in crash dumps for canary
+    // and dev channel builds.
+    if (channel_name == L"dev" ||
+        channel_name == GoogleChromeSxSDistribution::ChannelName()) {
+      dump_type = kLargerDumpType;
+      enable_handle_tracing = true;
+    }
+
+    // Capture more detail in crash dumps for beta builds.
+    if (channel_name == L"beta")
       dump_type = kLargerDumpType;
   }
 
+#if !defined(NDEBUG)
+  // Enable handle tracing for all debug builds.
+  enable_handle_tracing = true;
+#endif  // !defined(NDEBUG)
+
   g_breakpad = new google_breakpad::ExceptionHandler(temp_dir, &FilterCallback,
                    callback, NULL,
                    google_breakpad::ExceptionHandler::HANDLER_ALL,
                    dump_type, pipe_name.c_str(), custom_info);
 
   // Now initialize the non crash dump handler.
   g_dumphandler_no_crash = new google_breakpad::ExceptionHandler(temp_dir,
       &FilterCallbackWhenNoCrash,
       &DumpDoneCallbackWhenNoCrash,
       NULL,
       // Set the handler to none so this handler would not be added to
       // |handler_stack_| in |ExceptionHandler| which is a list of exception
       // handlers.
       google_breakpad::ExceptionHandler::HANDLER_NONE,
       dump_type, pipe_name.c_str(), custom_info);
 
   if (command.HasSwitch(switches::kPerformCrashAnalysis))
     g_crash_analysis = new CrashAnalysis();
 
   if (g_breakpad->IsOutOfProcess()) {
     // Tells breakpad to handle breakpoint and single step exceptions.
     // This might break JIT debuggers, but at least it will always
     // generate a crashdump for these exceptions.
     g_breakpad->set_handle_debug_exceptions(true);
   }
+
+  if (enable_handle_tracing)
+    EnableHandleTracing();
 }
 
 void InitDefaultCrashCallback(LPTOP_LEVEL_EXCEPTION_FILTER filter) {
   previous_filter = SetUnhandledExceptionFilter(filter);
 }
 
 void StringVectorToCStringVector(const std::vector<std::wstring>& wstrings,
                                  std::vector<const wchar_t*>* cstrings) {
   cstrings->clear();
   cstrings->reserve(wstrings.size());
   for (size_t i = 0; i < wstrings.size(); ++i)
     cstrings->push_back(wstrings[i].c_str());
 }