Move handle dumpage to the renderer process (so that it works correctly) and move handle enumerator into common.

BUG=96488
TEST=N/A
Review URL: http://codereview.chromium.org/7888024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@102004 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 419 insertions, 14 deletions

diff --git a/content/common/child_process_messages.h b/content/common/child_process_messages.h
index 32ff20b..b1a8b33 100644
--- a/content/common/child_process_messages.h
+++ b/content/common/child_process_messages.h
@@ -40,6 +40,9 @@ IPC_MESSAGE_CONTROL0(ChildProcessMsg_EndTracing)
 // Sent to all child processes to get trace buffer fullness.
 IPC_MESSAGE_CONTROL0(ChildProcessMsg_GetTraceBufferPercentFull)
 
+// Sent to child processes to dump their handle table.
+IPC_MESSAGE_CONTROL0(ChildProcessMsg_DumpHandles)
+
 ////////////////////////////////////////////////////////////////////////////////
 // Messages sent from the child process to the browser.
 
@@ -60,6 +63,9 @@ IPC_MESSAGE_CONTROL1(ChildProcessHostMsg_TraceDataCollected,
 IPC_MESSAGE_CONTROL1(ChildProcessHostMsg_TraceBufferPercentFullReply,
                      float /*trace buffer percent full*/)
 
+// Reply to ChildProcessMsg_DumpHandles when handle table dump is complete.
+IPC_MESSAGE_CONTROL0(ChildProcessHostMsg_DumpHandlesDone)
+
 #if defined(OS_WIN)
 // Request that the given font be loaded by the host so it's cached by the
 // OS. Please see ChildProcessHost::PreCacheFont for details.
diff --git a/content/common/child_thread.cc b/content/common/child_thread.cc
index 95d0080..f76c2a5 100644
--- a/content/common/child_thread.cc
+++ b/content/common/child_thread.cc
@@ -22,6 +22,10 @@
 #include "ipc/ipc_switches.h"
 #include "webkit/glue/webkit_glue.h"
 
+#if defined(OS_WIN)
+#include "content/common/handle_enumerator_win.h"
+#endif
+
 ChildThread::ChildThread() {
   channel_name_ = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kProcessChannelID);
@@ -158,6 +162,7 @@ bool ChildThread::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(ChildProcessMsg_SetIPCLoggingEnabled,
                         OnSetIPCLoggingEnabled)
 #endif
+    IPC_MESSAGE_HANDLER(ChildProcessMsg_DumpHandles, OnDumpHandles)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -191,6 +196,20 @@ void ChildThread::OnSetIPCLoggingEnabled(bool enable) {
 }
 #endif  //  IPC_MESSAGE_LOG_ENABLED
 
+void ChildThread::OnDumpHandles() {
+#if defined(OS_WIN)
+  scoped_refptr<content::HandleEnumerator> handle_enum(
+      new content::HandleEnumerator(
+          CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kAuditAllHandles)));
+  handle_enum->EnumerateHandles();
+  Send(new ChildProcessHostMsg_DumpHandlesDone);
+  return;
+#endif
+
+  NOTIMPLEMENTED();
+}
+
 ChildThread* ChildThread::current() {
   return ChildProcess::current()->main_thread();
 }
diff --git a/content/common/child_thread.h b/content/common/child_thread.h
index 8956ff2..356ffd5 100644
--- a/content/common/child_thread.h
+++ b/content/common/child_thread.h
@@ -87,6 +87,8 @@ class CONTENT_EXPORT ChildThread : public IPC::Channel::Listener,
   virtual void OnSetIPCLoggingEnabled(bool enable);
 #endif
 
+  virtual void OnDumpHandles();
+
   void set_on_channel_error_called(bool on_channel_error_called) {
     on_channel_error_called_ = on_channel_error_called;
   }
diff --git a/content/common/content_switches.cc b/content/common/content_switches.cc
index 4b232a4..6bafd31 100644
--- a/content/common/content_switches.cc
+++ b/content/common/content_switches.cc
@@ -17,6 +17,13 @@ const char kAllowRunningInsecureContent[]   = "allow-running-insecure-content";
 // Allows debugging of sandboxed processes (see zygote_main_linux.cc).
 const char kAllowSandboxDebugging[]         = "allow-sandbox-debugging";
 
+// Enumerates and prints a child process' most dangerous handles when it
+// is terminated.
+const char kAuditHandles[]                  = "enable-handle-auditing";
+
+// The same as kAuditHandles except all handles are enumerated.
+const char kAuditAllHandles[]               = "enable-handle-auditing-all";
+
 // Causes the browser process to throw an assertion on startup.
 const char kBrowserAssertTest[]             = "assert-test";
 
@@ -484,15 +491,6 @@ const char kZygoteCmdPrefix[]               = "zygote-cmd-prefix";
 // Causes the process to run as a renderer zygote.
 const char kZygoteProcess[]                 = "zygote";
 
-#if defined(OS_WIN)
-// Enumerates and prints a child process' most dangerous handles when it
-// is terminated.
-const char kAuditHandles[]                  = "enable-handle-auditing";
-
-// The same as kAuditHandles except all handles are enumerated.
-const char kAuditAllHandles[]               = "enable-handle-auditing-all";
-#endif
-
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // Specify the amount the trackpad should scroll by.
 const char kScrollPixels[]                  = "scroll-pixels";
diff --git a/content/common/content_switches.h b/content/common/content_switches.h
index ea1636b..8bf6e23 100644
--- a/content/common/content_switches.h
+++ b/content/common/content_switches.h
@@ -16,6 +16,8 @@ namespace switches {
 CONTENT_EXPORT extern const char kAllowFileAccessFromFiles[];
 CONTENT_EXPORT extern const char kAllowRunningInsecureContent[];
 extern const char kAllowSandboxDebugging[];
+extern const char kAuditHandles[];
+extern const char kAuditAllHandles[];
 CONTENT_EXPORT extern const char kBrowserAssertTest[];
 CONTENT_EXPORT extern const char kBrowserCrashTest[];
 extern const char kBrowserSubprocessPath[];
@@ -158,11 +160,6 @@ CONTENT_EXPORT extern const char kWorkerProcess[];
 CONTENT_EXPORT extern const char kZygoteCmdPrefix[];
 CONTENT_EXPORT extern const char kZygoteProcess[];
 
-#if defined(OS_WIN)
-extern const char kAuditHandles[];
-extern const char kAuditAllHandles[];
-#endif
-
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 extern const char kScrollPixels[];
 #endif
diff --git a/content/common/handle_enumerator_win.cc b/content/common/handle_enumerator_win.cc
new file mode 100644
index 0000000..c95ac10
--- /dev/null
+++ b/content/common/handle_enumerator_win.cc
@@ -0,0 +1,329 @@
+// Copyright (c) 2011 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 "content/common/handle_enumerator_win.h"
+
+#include <windows.h>
+#include <map>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/process.h"
+#include "base/process_util.h"
+#include "base/utf_string_conversions.h"
+#include "base/win/windows_version.h"
+#include "content/common/content_switches.h"
+#include "content/common/result_codes.h"
+#include "sandbox/src/handle_table.h"
+
+namespace {
+
+typedef std::map<const string16, content::HandleType> HandleTypeMap;
+
+HandleTypeMap& MakeHandleTypeMap() {
+  HandleTypeMap& handle_types = *(new HandleTypeMap());
+  handle_types[sandbox::HandleTable::kTypeProcess] = content::ProcessHandle;
+  handle_types[sandbox::HandleTable::kTypeThread] = content::ThreadHandle;
+  handle_types[sandbox::HandleTable::kTypeFile] = content::FileHandle;
+  handle_types[sandbox::HandleTable::kTypeDirectory] =
+      content::DirectoryHandle;
+  handle_types[sandbox::HandleTable::kTypeKey] = content::KeyHandle;
+  handle_types[sandbox::HandleTable::kTypeWindowStation] =
+      content::WindowStationHandle;
+  handle_types[sandbox::HandleTable::kTypeDesktop] = content::DesktopHandle;
+  handle_types[sandbox::HandleTable::kTypeService] = content::ServiceHandle;
+  handle_types[sandbox::HandleTable::kTypeMutex] = content::MutexHandle;
+  handle_types[sandbox::HandleTable::kTypeSemaphore] =
+      content::SemaphoreHandle;
+  handle_types[sandbox::HandleTable::kTypeEvent] = content::EventHandle;
+  handle_types[sandbox::HandleTable::kTypeTimer] = content::TimerHandle;
+  handle_types[sandbox::HandleTable::kTypeNamedPipe] =
+      content::NamedPipeHandle;
+  handle_types[sandbox::HandleTable::kTypeJobObject] = content::JobHandle;
+  handle_types[sandbox::HandleTable::kTypeFileMap] = content::FileMapHandle;
+  handle_types[sandbox::HandleTable::kTypeAlpcPort] =
+      content::AlpcPortHandle;
+
+  return handle_types;
+}
+
+}  // namespace
+
+namespace content {
+
+const size_t kMaxHandleNameLength = 1024;
+
+void HandleEnumerator::EnumerateHandles() {
+  sandbox::HandleTable handles;
+  std::string process_type =
+      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kProcessType);
+  string16 output = ASCIIToUTF16(process_type);
+  output.append(ASCIIToUTF16(" process - Handles at shutdown:\n"));
+  for (sandbox::HandleTable::Iterator sys_handle
+      = handles.HandlesForProcess(::GetCurrentProcessId());
+      sys_handle != handles.end(); ++sys_handle) {
+    HandleType current_type = StringToHandleType(sys_handle->Type());
+    if (!all_handles_ && (current_type != ProcessHandle &&
+                          current_type != FileHandle &&
+                          current_type != DirectoryHandle &&
+                          current_type != KeyHandle &&
+                          current_type != WindowStationHandle &&
+                          current_type != DesktopHandle &&
+                          current_type != ServiceHandle))
+      continue;
+
+    output += ASCIIToUTF16("[");
+    output += sys_handle->Type();
+    output += ASCIIToUTF16("] (");
+    output += sys_handle->Name();
+    output += ASCIIToUTF16(")\n");
+    output += GetAccessString(current_type,
+        sys_handle->handle_entry()->GrantedAccess);
+  }
+  LOG(INFO) << output;
+}
+
+HandleType StringToHandleType(const string16& type) {
+  static HandleTypeMap handle_types = MakeHandleTypeMap();
+  HandleTypeMap::iterator result = handle_types.find(type);
+  return result != handle_types.end() ? result->second : OtherHandle;
+}
+
+string16 GetAccessString(HandleType handle_type,
+                                           ACCESS_MASK access) {
+  string16 output;
+  if (access & GENERIC_READ)
+    output.append(ASCIIToUTF16("\tGENERIC_READ\n"));
+  if (access & GENERIC_WRITE)
+    output.append(ASCIIToUTF16("\tGENERIC_WRITE\n"));
+  if (access & GENERIC_EXECUTE)
+    output.append(ASCIIToUTF16("\tGENERIC_EXECUTE\n"));
+  if (access & GENERIC_ALL)
+    output.append(ASCIIToUTF16("\tGENERIC_ALL\n"));
+  if (access & DELETE)
+    output.append(ASCIIToUTF16("\tDELETE\n"));
+  if (access & READ_CONTROL)
+    output.append(ASCIIToUTF16("\tREAD_CONTROL\n"));
+  if (access & WRITE_DAC)
+    output.append(ASCIIToUTF16("\tWRITE_DAC\n"));
+  if (access & WRITE_OWNER)
+    output.append(ASCIIToUTF16("\tWRITE_OWNER\n"));
+  if (access & SYNCHRONIZE)
+    output.append(ASCIIToUTF16("\tSYNCHRONIZE\n"));
+
+  switch (handle_type) {
+    case ProcessHandle:
+      if (access & PROCESS_CREATE_PROCESS)
+        output.append(ASCIIToUTF16("\tPROCESS_CREATE_PROCESS\n"));
+      if (access & PROCESS_CREATE_THREAD)
+        output.append(ASCIIToUTF16("\tPROCESS_CREATE_THREAD\n"));
+      if (access & PROCESS_DUP_HANDLE)
+        output.append(ASCIIToUTF16("\tPROCESS_DUP_HANDLE\n"));
+      if (access & PROCESS_QUERY_INFORMATION)
+        output.append(ASCIIToUTF16("\tPROCESS_QUERY_INFORMATION\n"));
+      if (access & PROCESS_QUERY_LIMITED_INFORMATION)
+        output.append(ASCIIToUTF16("\tPROCESS_QUERY_LIMITED_INFORMATION\n"));
+      if (access & PROCESS_SET_INFORMATION)
+        output.append(ASCIIToUTF16("\tPROCESS_SET_INFORMATION\n"));
+      if (access & PROCESS_SET_QUOTA)
+        output.append(ASCIIToUTF16("\tPROCESS_SET_QUOTA\n"));
+      if (access & PROCESS_SUSPEND_RESUME)
+        output.append(ASCIIToUTF16("\tPROCESS_SUSPEND_RESUME\n"));
+      if (access & PROCESS_TERMINATE)
+        output.append(ASCIIToUTF16("\tPROCESS_TERMINATE\n"));
+      if (access & PROCESS_VM_OPERATION)
+        output.append(ASCIIToUTF16("\tPROCESS_VM_OPERATION\n"));
+      if (access & PROCESS_VM_READ)
+        output.append(ASCIIToUTF16("\tPROCESS_VM_READ\n"));
+      if (access & PROCESS_VM_WRITE)
+        output.append(ASCIIToUTF16("\tPROCESS_VM_WRITE\n"));
+      break;
+    case ThreadHandle:
+      if (access & THREAD_DIRECT_IMPERSONATION)
+        output.append(ASCIIToUTF16("\tTHREAD_DIRECT_IMPERSONATION\n"));
+      if (access & THREAD_GET_CONTEXT)
+        output.append(ASCIIToUTF16("\tTHREAD_GET_CONTEXT\n"));
+      if (access & THREAD_IMPERSONATE)
+        output.append(ASCIIToUTF16("\tTHREAD_IMPERSONATE\n"));
+      if (access & THREAD_QUERY_INFORMATION )
+        output.append(ASCIIToUTF16("\tTHREAD_QUERY_INFORMATION\n"));
+      if (access & THREAD_QUERY_LIMITED_INFORMATION)
+        output.append(ASCIIToUTF16("\tTHREAD_QUERY_LIMITED_INFORMATION\n"));
+      if (access & THREAD_SET_CONTEXT)
+        output.append(ASCIIToUTF16("\tTHREAD_SET_CONTEXT\n"));
+      if (access & THREAD_SET_INFORMATION)
+        output.append(ASCIIToUTF16("\tTHREAD_SET_INFORMATION\n"));
+      if (access & THREAD_SET_LIMITED_INFORMATION)
+        output.append(ASCIIToUTF16("\tTHREAD_SET_LIMITED_INFORMATION\n"));
+      if (access & THREAD_SET_THREAD_TOKEN)
+        output.append(ASCIIToUTF16("\tTHREAD_SET_THREAD_TOKEN\n"));
+      if (access & THREAD_SUSPEND_RESUME)
+        output.append(ASCIIToUTF16("\tTHREAD_SUSPEND_RESUME\n"));
+      if (access & THREAD_TERMINATE)
+        output.append(ASCIIToUTF16("\tTHREAD_TERMINATE\n"));
+      break;
+    case FileHandle:
+      if (access & FILE_APPEND_DATA)
+        output.append(ASCIIToUTF16("\tFILE_APPEND_DATA\n"));
+      if (access & FILE_EXECUTE)
+        output.append(ASCIIToUTF16("\tFILE_EXECUTE\n"));
+      if (access & FILE_READ_ATTRIBUTES)
+        output.append(ASCIIToUTF16("\tFILE_READ_ATTRIBUTES\n"));
+      if (access & FILE_READ_DATA)
+        output.append(ASCIIToUTF16("\tFILE_READ_DATA\n"));
+      if (access & FILE_READ_EA)
+        output.append(ASCIIToUTF16("\tFILE_READ_EA\n"));
+      if (access & FILE_WRITE_ATTRIBUTES)
+        output.append(ASCIIToUTF16("\tFILE_WRITE_ATTRIBUTES\n"));
+      if (access & FILE_WRITE_DATA)
+        output.append(ASCIIToUTF16("\tFILE_WRITE_DATA\n"));
+      if (access & FILE_WRITE_EA)
+        output.append(ASCIIToUTF16("\tFILE_WRITE_EA\n"));
+      if (access & FILE_WRITE_EA)
+        output.append(ASCIIToUTF16("\tFILE_WRITE_EA\n"));
+      break;
+    case DirectoryHandle:
+      if (access & FILE_ADD_FILE)
+        output.append(ASCIIToUTF16("\tFILE_ADD_FILE\n"));
+      if (access & FILE_ADD_SUBDIRECTORY)
+        output.append(ASCIIToUTF16("\tFILE_ADD_SUBDIRECTORY\n"));
+      if (access & FILE_APPEND_DATA)
+        output.append(ASCIIToUTF16("\tFILE_APPEND_DATA\n"));
+      if (access & FILE_DELETE_CHILD)
+        output.append(ASCIIToUTF16("\tFILE_DELETE_CHILD\n"));
+      if (access & FILE_LIST_DIRECTORY)
+        output.append(ASCIIToUTF16("\tFILE_LIST_DIRECTORY\n"));
+      if (access & FILE_READ_DATA)
+        output.append(ASCIIToUTF16("\tFILE_READ_DATA\n"));
+      if (access & FILE_TRAVERSE)
+        output.append(ASCIIToUTF16("\tFILE_TRAVERSE\n"));
+      if (access & FILE_WRITE_DATA)
+        output.append(ASCIIToUTF16("\tFILE_WRITE_DATA\n"));
+      break;
+    case KeyHandle:
+      if (access & KEY_CREATE_LINK)
+        output.append(ASCIIToUTF16("\tKEY_CREATE_LINK\n"));
+      if (access & KEY_CREATE_SUB_KEY)
+        output.append(ASCIIToUTF16("\tKEY_CREATE_SUB_KEY\n"));
+      if (access & KEY_ENUMERATE_SUB_KEYS)
+        output.append(ASCIIToUTF16("\tKEY_ENUMERATE_SUB_KEYS\n"));
+      if (access & KEY_EXECUTE)
+        output.append(ASCIIToUTF16("\tKEY_EXECUTE\n"));
+      if (access & KEY_NOTIFY)
+        output.append(ASCIIToUTF16("\tKEY_NOTIFY\n"));
+      if (access & KEY_QUERY_VALUE)
+        output.append(ASCIIToUTF16("\tKEY_QUERY_VALUE\n"));
+      if (access & KEY_READ)
+        output.append(ASCIIToUTF16("\tKEY_READ\n"));
+      if (access & KEY_SET_VALUE)
+        output.append(ASCIIToUTF16("\tKEY_SET_VALUE\n"));
+      if (access & KEY_WOW64_32KEY)
+        output.append(ASCIIToUTF16("\tKEY_WOW64_32KEY\n"));
+      if (access & KEY_WOW64_64KEY)
+        output.append(ASCIIToUTF16("\tKEY_WOW64_64KEY\n"));
+      break;
+    case WindowStationHandle:
+      if (access & WINSTA_ACCESSCLIPBOARD)
+        output.append(ASCIIToUTF16("\tWINSTA_ACCESSCLIPBOARD\n"));
+      if (access & WINSTA_ACCESSGLOBALATOMS)
+        output.append(ASCIIToUTF16("\tWINSTA_ACCESSGLOBALATOMS\n"));
+      if (access & WINSTA_CREATEDESKTOP)
+        output.append(ASCIIToUTF16("\tWINSTA_CREATEDESKTOP\n"));
+      if (access & WINSTA_ENUMDESKTOPS)
+        output.append(ASCIIToUTF16("\tWINSTA_ENUMDESKTOPS\n"));
+      if (access & WINSTA_ENUMERATE)
+        output.append(ASCIIToUTF16("\tWINSTA_ENUMERATE\n"));
+      if (access & WINSTA_EXITWINDOWS)
+        output.append(ASCIIToUTF16("\tWINSTA_EXITWINDOWS\n"));
+      if (access & WINSTA_READATTRIBUTES)
+        output.append(ASCIIToUTF16("\tWINSTA_READATTRIBUTES\n"));
+      if (access & WINSTA_READSCREEN)
+        output.append(ASCIIToUTF16("\tWINSTA_READSCREEN\n"));
+      if (access & WINSTA_WRITEATTRIBUTES)
+        output.append(ASCIIToUTF16("\tWINSTA_WRITEATTRIBUTES\n"));
+      break;
+    case DesktopHandle:
+      if (access & DESKTOP_CREATEMENU)
+        output.append(ASCIIToUTF16("\tDESKTOP_CREATEMENU\n"));
+      if (access & DESKTOP_CREATEWINDOW)
+        output.append(ASCIIToUTF16("\tDESKTOP_CREATEWINDOW\n"));
+      if (access & DESKTOP_ENUMERATE)
+        output.append(ASCIIToUTF16("\tDESKTOP_ENUMERATE\n"));
+      if (access & DESKTOP_HOOKCONTROL)
+        output.append(ASCIIToUTF16("\tDESKTOP_HOOKCONTROL\n"));
+      if (access & DESKTOP_JOURNALPLAYBACK)
+        output.append(ASCIIToUTF16("\tDESKTOP_JOURNALPLAYBACK\n"));
+      if (access & DESKTOP_JOURNALRECORD)
+        output.append(ASCIIToUTF16("\tDESKTOP_JOURNALRECORD\n"));
+      if (access & DESKTOP_READOBJECTS)
+        output.append(ASCIIToUTF16("\tDESKTOP_READOBJECTS\n"));
+      if (access & DESKTOP_SWITCHDESKTOP)
+        output.append(ASCIIToUTF16("\tDESKTOP_SWITCHDESKTOP\n"));
+      if (access & DESKTOP_WRITEOBJECTS)
+        output.append(ASCIIToUTF16("\tDESKTOP_WRITEOBJECTS\n"));
+      break;
+    case ServiceHandle:
+      if (access & SC_MANAGER_CREATE_SERVICE)
+        output.append(ASCIIToUTF16("\tSC_MANAGER_CREATE_SERVICE\n"));
+      if (access & SC_MANAGER_CONNECT)
+        output.append(ASCIIToUTF16("\tSC_MANAGER_CONNECT\n"));
+      if (access & SC_MANAGER_ENUMERATE_SERVICE )
+        output.append(ASCIIToUTF16("\tSC_MANAGER_ENUMERATE_SERVICE\n"));
+      if (access & SC_MANAGER_LOCK)
+        output.append(ASCIIToUTF16("\tSC_MANAGER_LOCK\n"));
+      if (access & SC_MANAGER_MODIFY_BOOT_CONFIG )
+        output.append(ASCIIToUTF16("\tSC_MANAGER_MODIFY_BOOT_CONFIG\n"));
+      if (access & SC_MANAGER_QUERY_LOCK_STATUS )
+        output.append(ASCIIToUTF16("\tSC_MANAGER_QUERY_LOCK_STATUS\n"));
+      break;
+    case EventHandle:
+      if (access & EVENT_MODIFY_STATE)
+        output.append(ASCIIToUTF16("\tEVENT_MODIFY_STATE\n"));
+      break;
+    case MutexHandle:
+      if (access & MUTEX_MODIFY_STATE)
+        output.append(ASCIIToUTF16("\tMUTEX_MODIFY_STATE\n"));
+      break;
+    case SemaphoreHandle:
+      if (access & SEMAPHORE_MODIFY_STATE)
+        output.append(ASCIIToUTF16("\tSEMAPHORE_MODIFY_STATE\n"));
+      break;
+    case TimerHandle:
+      if (access & TIMER_MODIFY_STATE)
+        output.append(ASCIIToUTF16("\tTIMER_MODIFY_STATE\n"));
+      if (access & TIMER_QUERY_STATE)
+        output.append(ASCIIToUTF16("\tTIMER_QUERY_STATE\n"));
+      break;
+    case NamedPipeHandle:
+      if (access & PIPE_ACCESS_INBOUND)
+        output.append(ASCIIToUTF16("\tPIPE_ACCESS_INBOUND\n"));
+      if (access & PIPE_ACCESS_OUTBOUND)
+        output.append(ASCIIToUTF16("\tPIPE_ACCESS_OUTBOUND\n"));
+      break;
+    case JobHandle:
+      if (access & JOB_OBJECT_ASSIGN_PROCESS)
+        output.append(ASCIIToUTF16("\tJOB_OBJECT_ASSIGN_PROCESS\n"));
+      if (access & JOB_OBJECT_QUERY)
+        output.append(ASCIIToUTF16("\tJOB_OBJECT_QUERY\n"));
+      if (access & JOB_OBJECT_SET_ATTRIBUTES)
+        output.append(ASCIIToUTF16("\tJOB_OBJECT_SET_ATTRIBUTES\n"));
+      if (access & JOB_OBJECT_SET_SECURITY_ATTRIBUTES)
+        output.append(ASCIIToUTF16("\tJOB_OBJECT_SET_SECURITY_ATTRIBUTES\n"));
+      if (access & JOB_OBJECT_TERMINATE)
+        output.append(ASCIIToUTF16("\tJOB_OBJECT_TERMINATE\n"));
+      break;
+    case FileMapHandle:
+      if (access & FILE_MAP_EXECUTE)
+        output.append(ASCIIToUTF16("\tFILE_MAP_EXECUTE\n"));
+      if (access & FILE_MAP_READ)
+        output.append(ASCIIToUTF16("\tFILE_MAP_READ\n"));
+      if (access & FILE_MAP_WRITE)
+        output.append(ASCIIToUTF16("\tFILE_MAP_WRITE\n"));
+      break;
+  }
+  return output;
+}
+
+}  // namespace content
diff --git a/content/common/handle_enumerator_win.h b/content/common/handle_enumerator_win.h
new file mode 100644
index 0000000..ada972f
--- /dev/null
+++ b/content/common/handle_enumerator_win.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2011 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.
+
+#ifndef CONTENT_COMMON_HANDLE_ENUMERATOR_WIN_H_
+#define CONTENT_COMMON_HANDLE_ENUMERATOR_WIN_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/process.h"
+#include "base/string16.h"
+
+namespace content {
+
+enum HandleType {
+  ProcessHandle,
+  ThreadHandle,
+  FileHandle,
+  DirectoryHandle,
+  KeyHandle,
+  WindowStationHandle,
+  DesktopHandle,
+  ServiceHandle,
+  EventHandle,
+  MutexHandle,
+  SemaphoreHandle,
+  TimerHandle,
+  NamedPipeHandle,
+  JobHandle,
+  FileMapHandle,
+  AlpcPortHandle,
+  OtherHandle
+};
+
+static HandleType StringToHandleType(const string16& type);
+
+static string16 GetAccessString(HandleType handle_type, ACCESS_MASK access);
+
+class HandleEnumerator : public base::RefCountedThreadSafe<HandleEnumerator> {
+ public:
+  explicit HandleEnumerator(bool all_handles):
+      all_handles_(all_handles) { }
+
+  void EnumerateHandles();
+
+ private:
+  bool all_handles_;
+
+  DISALLOW_COPY_AND_ASSIGN(HandleEnumerator);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_HANDLE_ENUMERATOR_WIN_H_
+