Fixing level 4 warnings

src/client/windows/handler/exception_handler.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 78 matching lines @@
   Initialize(dump_path,
              filter,
              callback,
              callback_context,
              handler_types,
              dump_type,
              NULL,  // pipe_name
              pipe_handle,
              NULL,  // crash_generation_client
              custom_info);
-}  
+}
 
 ExceptionHandler::ExceptionHandler(
     const wstring& dump_path,
     FilterCallback filter,
     MinidumpCallback callback,
     void* callback_context,
     int handler_types,
-    MINIDUMP_TYPE dump_type,
-    CrashGenerationClient* crash_generation_client,
-    const CustomClientInfo* custom_info) {
+    CrashGenerationClient* crash_generation_client) {
+  // The dump_type, pipe_name and custom_info that are passed in to Initialize()
+  // are not used.  The ones set in crash_generation_client are used instead.
   Initialize(dump_path,
              filter,
              callback,
              callback_context,
              handler_types,
-             MiniDumpNormal,
-             NULL,  // pipe_name
-             NULL,  // pipe_handle
+             MiniDumpNormal,           // dump_type - not used
+             NULL,                     // pipe_name - not used
+             NULL,                     // pipe_handle
              crash_generation_client,
-             custom_info);
+             NULL);                    // custom_info - not used
 }
 
 ExceptionHandler::ExceptionHandler(const wstring &dump_path,
                                    FilterCallback filter,
                                    MinidumpCallback callback,
                                    void* callback_context,
                                    int handler_types) {
   Initialize(dump_path,
              filter,
              callback,
@@ skipping 249 matching lines @@
   return crash_generation_client_->RequestUpload(crash_id);
 }
 
 // static
 DWORD ExceptionHandler::ExceptionHandlerThreadMain(void* lpParameter) {
   ExceptionHandler* self = reinterpret_cast<ExceptionHandler *>(lpParameter);
   assert(self);
   assert(self->handler_start_semaphore_ != NULL);
   assert(self->handler_finish_semaphore_ != NULL);
 
-  while (true) {
+  for (;;) {

[Mark Mentovai, 2013/05/30 19:06:44]

Leave this as while (true).

[Ivan Penkov, 2013/05/30 22:40:54]

Bummer.  I did fix those, but I did the change through meld and apparently it
failed to overwrite the original file. Sorry.  It is done now for real.

     if (WaitForSingleObject(self->handler_start_semaphore_, INFINITE) ==
         WAIT_OBJECT_0) {
       // Perform the requested action.
       if (self->is_shutdown_) {
         // The instance of the exception handler is being destroyed.
         break;
       } else {
         self->handler_return_value_ =
             self->WriteMinidumpWithException(self->requesting_thread_id_,
                                              self->exception_info_,
@@ skipping 468 matching lines @@
         reinterpret_cast<MinidumpCallbackContext*>(context);
     if (callback_context->iter == callback_context->end)
       return FALSE;
 
     // Include the specified memory region.
     callback_output->MemoryBase = callback_context->iter->ptr;
     callback_output->MemorySize = callback_context->iter->length;
     callback_context->iter++;
     return TRUE;
   }
-    
+
     // Include all modules.
   case IncludeModuleCallback:
   case ModuleCallback:
     return TRUE;
 
     // Include all threads.
   case IncludeThreadCallback:
   case ThreadCallback:
     return TRUE;
 
@@ skipping 169 matching lines @@
 
 void ExceptionHandler::UnregisterAppMemory(void* ptr) {
   AppMemoryList::iterator iter =
     std::find(app_memory_info_.begin(), app_memory_info_.end(), ptr);
   if (iter != app_memory_info_.end()) {
     app_memory_info_.erase(iter);
   }
 }
 
 }  // namespace google_breakpad