win: Don't duplicate handles in handle restriction list

client/crashpad_client_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 114 matching lines @@
     static const auto delete_proc_thread_attribute_list =
         GET_FUNCTION_REQUIRED(L"kernel32.dll", ::DeleteProcThreadAttributeList);
     delete_proc_thread_attribute_list(proc_thread_attribute_list);
   }
 };
 
 using ScopedProcThreadAttributeList =
     base::ScopedGeneric<PPROC_THREAD_ATTRIBUTE_LIST,
                         ScopedProcThreadAttributeListTraits>;
 
-// Adds |handle| to |handle_list| if it appears valid.
+// Adds |handle| to |handle_list| if it appears valid, and is not already in
+// |handle_list|.
 //
 // Invalid handles (including INVALID_HANDLE_VALUE and null handles) cannot be
 // added to a PPROC_THREAD_ATTRIBUTE_LIST’s PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
 // If INVALID_HANDLE_VALUE appears, CreateProcess() will fail with
 // ERROR_INVALID_PARAMETER. If a null handle appears, the child process will
 // silently not inherit any handles.
 //
 // Use this function to add handles with uncertain validities.
 void AddHandleToListIfValid(std::vector<HANDLE>* handle_list, HANDLE handle) {
-  if (handle && handle != INVALID_HANDLE_VALUE) {
+  // There doesn't seem to be any documentation of this, but if there's a handle
+  // duplicated in this list, CreateProcess() fails with
+  // ERROR_INVALID_PARAMETER.
+  if (handle && handle != INVALID_HANDLE_VALUE &&
+      std::find(handle_list->begin(), handle_list->end(), handle) ==
+          handle_list->end()) {
     handle_list->push_back(handle);
   }
 }
 
 }  // namespace
 
 namespace crashpad {
 
 CrashpadClient::CrashpadClient()
     : ipc_pipe_() {
@@ skipping 174 matching lines @@
   DCHECK(!ipc_pipe_.empty());
   return ipc_pipe_;
 }
 
 bool CrashpadClient::UseHandler() {
   DCHECK(!ipc_pipe_.empty());
   DCHECK_EQ(g_signal_exception, INVALID_HANDLE_VALUE);
   DCHECK_EQ(g_signal_non_crash_dump, INVALID_HANDLE_VALUE);
   DCHECK_EQ(g_non_crash_dump_done, INVALID_HANDLE_VALUE);
   DCHECK(!g_critical_section_with_debug_info.DebugInfo);
+  DCHECK(!g_non_crash_dump_lock);
 
   ClientToServerMessage message;
   memset(&message, 0, sizeof(message));
   message.type = ClientToServerMessage::kRegister;
   message.registration.version = RegistrationRequest::kMessageVersion;
   message.registration.client_process_id = GetCurrentProcessId();
   message.registration.crash_exception_information =
       reinterpret_cast<WinVMAddress>(&g_crash_exception_information);
   message.registration.non_crash_exception_information =
       reinterpret_cast<WinVMAddress>(&g_non_crash_exception_information);
@@ skipping 84 matching lines @@
   DWORD wfso_result = WaitForSingleObject(g_non_crash_dump_done, INFINITE);
   PLOG_IF(ERROR, wfso_result != WAIT_OBJECT_0) << "WaitForSingleObject";
 }
 
 // static
 void CrashpadClient::DumpAndCrash(EXCEPTION_POINTERS* exception_pointers) {
   UnhandledExceptionHandler(exception_pointers);
 }
 
 }  // namespace crashpad