win: Avoid some more clang complaints

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 350 matching lines @@
   // allows us to walk the list at crash time to gather data for !locks. A
   // debugger would instead inspect ntdll!RtlCriticalSectionList to get the head
   // of the list. But that is not an exported symbol, so on an arbitrary client
   // machine, we don't have a way of getting that pointer.
   if (InitializeCriticalSectionWithDebugInfoIfPossible(
           &g_critical_section_with_debug_info)) {
     message.registration.critical_section_address =
         reinterpret_cast<WinVMAddress>(&g_critical_section_with_debug_info);
   }
 
-  ServerToClientMessage response = {0};
+  ServerToClientMessage response = {};
 
   if (!SendToCrashHandlerServer(ipc_pipe_, message, &response)) {
     return false;
   }
 
   // The server returns these already duplicated to be valid in this process.
   g_signal_exception =
       IntToHandle(response.registration.request_crash_dump_event);
   g_signal_non_crash_dump =
       IntToHandle(response.registration.request_non_crash_dump_event);
@@ skipping 19 matching lines @@
   // In the non-crashing case, we aren't concerned about avoiding calls into
   // Win32 APIs, so just use regular locking here in case of multiple threads
   // calling this function. If a crash occurs while we're in here, the worst
   // that can happen is that the server captures a partial dump for this path
   // because on the other thread gathering a crash dump, it TerminateProcess()d,
   // causing this one to abort.
   base::AutoLock lock(*g_non_crash_dump_lock);
 
   // Create a fake EXCEPTION_POINTERS to give the handler something to work
   // with.
-  EXCEPTION_POINTERS exception_pointers = {0};
+  EXCEPTION_POINTERS exception_pointers = {};
 
   // This is logically const, but EXCEPTION_POINTERS does not declare it as
   // const, so we have to cast that away from the argument.
   exception_pointers.ContextRecord = const_cast<CONTEXT*>(&context);
 
   // We include a fake exception and use a code of '0x517a7ed' (something like
   // "simulated") so that it's relatively obvious in windbg that it's not
   // actually an exception. Most values in
   // https://msdn.microsoft.com/en-us/library/windows/desktop/aa363082.aspx have
   // some of the top nibble set, so we make sure to pick a value that doesn't,
   // so as to be unlikely to conflict.
   const uint32_t kSimulatedExceptionCode = 0x517a7ed;
-  EXCEPTION_RECORD record = {0};
+  EXCEPTION_RECORD record = {};
   record.ExceptionCode = kSimulatedExceptionCode;
 #if defined(ARCH_CPU_64_BITS)
   record.ExceptionAddress = reinterpret_cast<void*>(context.Rip);
 #else
   record.ExceptionAddress = reinterpret_cast<void*>(context.Eip);
 #endif  // ARCH_CPU_64_BITS
 
   exception_pointers.ExceptionRecord = &record;
 
   g_non_crash_exception_information.thread_id = GetCurrentThreadId();
   g_non_crash_exception_information.exception_pointers =
       reinterpret_cast<crashpad::WinVMAddress>(&exception_pointers);
 
   bool set_event_result = !!SetEvent(g_signal_non_crash_dump);
   PLOG_IF(ERROR, !set_event_result) << "SetEvent";
 
   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