Integrate fallback crash handling in chrome

components/crash/content/app/fallback_crash_handler_win.cc

 // Copyright 2017 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 "components/crash/content/app/fallback_crash_handler_win.h"
 
 #include <dbghelp.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 143 matching lines @@
     return false;
 
   // Seek to the tail of the file, where we're going to extend it.
   FilePosition next_available_byte = file_->Seek(base::File::FROM_END, 0);
   if (next_available_byte == kInvalidFilePos)
     return false;
 
   // Write the key/value pairs and collect their locations.
   std::vector<crashpad::MinidumpSimpleStringDictionaryEntry> entries;
   for (const auto& kv : crash_keys) {
+    // The key of a key/value pair should never be empty.
+    DCHECK(!kv.first.empty());
+
     crashpad::MinidumpSimpleStringDictionaryEntry entry = {0};
 
-    entry.key = next_available_byte;
-    uint32_t key_len = base::saturated_cast<uint32_t>(kv.first.size());
-    if (!WriteAndAdvance(&key_len, sizeof(key_len), &next_available_byte) ||
-        !WriteAndAdvance(&kv.first[0], key_len, &next_available_byte)) {
-      return false;
+    // Skip this key/value if the value is empty.
+    if (!kv.second.empty()) {
+      entry.key = next_available_byte;
+      uint32_t key_len = base::saturated_cast<uint32_t>(kv.first.size());
+      if (!WriteAndAdvance(&key_len, sizeof(key_len), &next_available_byte) ||
+          !WriteAndAdvance(&kv.first[0], key_len, &next_available_byte)) {
+        return false;
+      }
+
+      entry.value = next_available_byte;
+      uint32_t value_len = base::saturated_cast<uint32_t>(kv.second.size());
+      if (!WriteAndAdvance(&value_len, sizeof(value_len),
+                           &next_available_byte) ||
+          !WriteAndAdvance(&kv.second[0], value_len, &next_available_byte)) {
+        return false;
+      }
+
+      entries.push_back(entry);
     }
-
-    entry.value = next_available_byte;
-    uint32_t value_len = base::saturated_cast<uint32_t>(kv.second.size());
-    if (!WriteAndAdvance(&value_len, sizeof(value_len), &next_available_byte) ||
-        !WriteAndAdvance(&kv.second[0], value_len, &next_available_byte)) {
-      return false;
-    }
-
-    entries.push_back(entry);
   }
 
   // Write the dictionary array itself - note the array is count-prefixed.
   FilePosition dict_pos = next_available_byte;
   uint32_t entry_count = base::saturated_cast<uint32_t>(entries.size());
   if (!WriteAndAdvance(&entry_count, sizeof(entry_count),
                        &next_available_byte) ||
       !WriteAndAdvance(&entries[0], entry_count * sizeof(entries[0]),
                        &next_available_byte)) {
     return false;
@@ skipping 142 matching lines @@
     return false;
   }
 
   // Before taking ownership of the supposed handle, see whether it's really
   // a process handle.
   base::ProcessHandle process_handle = base::win::Uint32ToHandle(uint_process);
   if (base::GetProcId(process_handle) == base::kNullProcessId)
     return false;
 
   // Retrieve the thread id argument.
-  unsigned thread_id = 0;
+  unsigned int thread_id = 0;
   if (!base::StringToUint(cmd_line.GetSwitchValueASCII("thread"), &thread_id)) {
     return false;
   }
+  thread_id_ = thread_id;
 
   // Retrieve the "exception-pointers" argument.
   uint64_t uint_exc_ptrs = 0;
   if (!base::StringToUint64(cmd_line.GetSwitchValueASCII("exception-pointers"),
                             &uint_exc_ptrs)) {
     return false;
   }
   exception_ptrs_ = static_cast<uintptr_t>(uint_exc_ptrs);
 
   // Retrieve the "database" argument.
@@ skipping 86 matching lines @@
 
   crashpad::UUID report_id = {};
   status = database->FinishedWritingCrashReport(report, &report_id);
   if (status != crashpad::CrashReportDatabase::kNoError)
     return false;
 
   return true;
 }
 
 }  // namespace crash_reporter