More code clean up

src/client/mac/handler/minidump_generator.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 176 matching lines @@
   // If opening was successful, create the header, directory, and call each
   // writer.  The destructor for the TypedMDRVAs will cause the data to be
   // flushed.  The destructor for the MinidumpFileWriter will close the file.
   if (writer_.Open(path)) {
     TypedMDRVA<MDRawHeader> header(&writer_);
     TypedMDRVA<MDRawDirectory> dir(&writer_);
 
     if (!header.Allocate())
       return false;
 
-    int writer_count = sizeof(writers) / sizeof(writers[0]);
+    int writer_count = static_cast<int>(sizeof(writers) / sizeof(writers[0]));
 
     // If we don't have exception information, don't write out the
     // exception stream
     if (!exception_thread_ && !exception_type_)
       --writer_count;
 
     // Add space for all writers
     if (!dir.AllocateArray(writer_count))
       return false;
 
@@ skipping 143 matching lines @@
 
   if (!context.Allocate())
     return false;
 
   *register_location = context.location();
   MinidumpContext *context_ptr = context.get();
   context_ptr->context_flags = MD_CONTEXT_PPC_BASE;
 
 #define AddReg(a) context_ptr->a = REGISTER_FROM_THREADSTATE(machine_state, a)
 #define AddGPR(a) context_ptr->gpr[a] = REGISTER_FROM_THREADSTATE(machine_state, r ## a)
- 
+
   AddReg(srr0);
   AddReg(cr);
   AddReg(xer);
   AddReg(ctr);
   AddReg(lr);
   AddReg(vrsave);
 
   AddGPR(0);
   AddGPR(1);
   AddGPR(2);
@@ skipping 126 matching lines @@
 #endif
 #undef AddReg(a)
 
   return true;
 }
 #endif
 
 bool MinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
                                           MDRawThread *thread) {
   breakpad_thread_state_data_t state;
-  mach_msg_type_number_t state_count = sizeof(state);
+  mach_msg_type_number_t state_count
+      = static_cast<mach_msg_type_number_t>(sizeof(state));
 
   if (thread_get_state(thread_id, BREAKPAD_MACHINE_THREAD_STATE,
                        state, &state_count) ==
       KERN_SUCCESS) {
     if (!WriteStack(state, &thread->stack))
       return false;
 
     if (!WriteContext(state, &thread->thread_context))
       return false;
 
@@ skipping 54 matching lines @@
   exception_stream->location = exception.location();
   MDRawExceptionStream *exception_ptr = exception.get();
   exception_ptr->thread_id = exception_thread_;
 
   // This naming is confusing, but it is the proper translation from
   // mach naming to minidump naming.
   exception_ptr->exception_record.exception_code = exception_type_;
   exception_ptr->exception_record.exception_flags = exception_code_;
 
   breakpad_thread_state_data_t state;
-  mach_msg_type_number_t stateCount = sizeof(state);
+  mach_msg_type_number_t stateCount
+      = static_cast<mach_msg_type_number_t>(sizeof(state));
 
   if (thread_get_state(exception_thread_,
                        BREAKPAD_MACHINE_THREAD_STATE,
                        state,
                        &stateCount) != KERN_SUCCESS)
     return false;
 
   if (!WriteContext(state, &exception_ptr->thread_context))
     return false;
 
@@ skipping 333 matching lines @@
 bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
   TypedMDRVA<MDRawMiscInfo> info(&writer_);
 
   if (!info.Allocate())
     return false;
 
   misc_info_stream->stream_type = MD_MISC_INFO_STREAM;
   misc_info_stream->location = info.location();
 
   MDRawMiscInfo *info_ptr = info.get();
-  info_ptr->size_of_info = sizeof(MDRawMiscInfo);
+  info_ptr->size_of_info = static_cast<u_int32_t>(sizeof(MDRawMiscInfo));
   info_ptr->flags1 = MD_MISCINFO_FLAGS1_PROCESS_ID |
     MD_MISCINFO_FLAGS1_PROCESS_TIMES |
     MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO;
 
   // Process ID
   info_ptr->process_id = getpid();
 
   // Times
   struct rusage usage;
   if (getrusage(RUSAGE_SELF, &usage) != -1) {
     // Omit the fractional time since the MDRawMiscInfo only wants seconds
     info_ptr->process_user_time =
         static_cast<u_int32_t>(usage.ru_utime.tv_sec);
     info_ptr->process_kernel_time =
         static_cast<u_int32_t>(usage.ru_stime.tv_sec);
   }
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, info_ptr->process_id };
+  u_int mibsize = static_cast<u_int>(sizeof(mib) / sizeof(mib[0]));

[Mark Mentovai, 2010/07/28 18:20:42]

I was surprised to see you using u_int instead of unsigned int (or something
else like size_t), but sure enough, the man page and header both use the u_int
typedef. Go figure.

   size_t size;
-  if (!sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &size, NULL, 0)) {
+  if (!sysctl(mib, mibsize, NULL, &size, NULL, 0)) {
     mach_vm_address_t addr;
     if (mach_vm_allocate(mach_task_self(),
                          &addr,
                          size,
                          true) == KERN_SUCCESS) {
       struct kinfo_proc *proc = (struct kinfo_proc *)addr;
-      if (!sysctl(mib, sizeof(mib) / sizeof(mib[0]), proc, &size, NULL, 0))
+      if (!sysctl(mib, mibsize, proc, &size, NULL, 0))
         info_ptr->process_create_time =
             static_cast<u_int32_t>(proc->kp_proc.p_starttime.tv_sec);
       mach_vm_deallocate(mach_task_self(), addr, size);
     }
   }
 
   // Speed
   uint64_t speed;
   const uint64_t kOneMillion = 1000 * 1000;
   size = sizeof(speed);
@@ skipping 26 matching lines @@
   } else {
     info_ptr->validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID;
     info_ptr->dump_thread_id = handler_thread_;
     info_ptr->requesting_thread_id = 0;
   }
 
   return true;
 }
 
 }  // namespace google_breakpad