List all crashes in chrome://crashes, including those not uploaded

components/crash/content/app/crashpad.cc

 // Copyright 2015 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/crashpad.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #if BUILDFLAG(ENABLE_KASKO)
@@ skipping 251 matching lines @@
     crashpad::Settings* settings = g_database->GetSettings();
     bool enable_uploads;
     if (settings->GetUploadsEnabled(&enable_uploads)) {
       return enable_uploads;
     }
   }
 
   return false;
 }
 
-void GetUploadedReports(std::vector<UploadedReport>* uploaded_reports) {
-  uploaded_reports->clear();
+void GetReports(std::vector<Report>* reports) {
+  reports->clear();
 
   if (!g_database) {
     return;
   }
 
   std::vector<crashpad::CrashReportDatabase::Report> completed_reports;
   crashpad::CrashReportDatabase::OperationStatus status =
       g_database->GetCompletedReports(&completed_reports);
   if (status != crashpad::CrashReportDatabase::kNoError) {
     return;
   }
 
+  std::vector<crashpad::CrashReportDatabase::Report> pending_reports;
+  status = g_database->GetPendingReports(&pending_reports);
+  if (status != crashpad::CrashReportDatabase::kNoError) {
+    return;
+  }
+
   for (const crashpad::CrashReportDatabase::Report& completed_report :
        completed_reports) {
+    Report report;
+    report.local_id = completed_report.uuid.ToString();
+    report.capture_time = completed_report.creation_time;
+    report.remote_id = completed_report.id;
     if (completed_report.uploaded) {
-      UploadedReport uploaded_report;
-      uploaded_report.local_id = completed_report.uuid.ToString();
-      uploaded_report.remote_id = completed_report.id;
-      uploaded_report.creation_time = completed_report.creation_time;
-
-      uploaded_reports->push_back(uploaded_report);
+      report.upload_time = completed_report.last_upload_attempt_time;
+      report.state = ReportUploadState::Uploaded;
+    } else {
+      report.upload_time = 0;
+      report.state = ReportUploadState::NotUploaded;
     }
+    reports->push_back(report);
   }
 
-  std::sort(uploaded_reports->begin(), uploaded_reports->end(),
-            [](const UploadedReport& a, const UploadedReport& b) {
-              return a.creation_time > b.creation_time;
+  for (const crashpad::CrashReportDatabase::Report& pending_report :
+       pending_reports) {
+    Report report;
+    report.local_id = pending_report.uuid.ToString();
+    report.capture_time = pending_report.creation_time;
+    report.upload_time = 0;
+    report.state = ReportUploadState::Pending;
+    reports->push_back(report);
+  }
+
+  std::sort(reports->begin(), reports->end(),
+            [](const Report& a, const Report& b) {
+              return a.capture_time > b.capture_time;
             });
 }
 
 #if BUILDFLAG(ENABLE_KASKO)
 
 void GetCrashKeysForKasko(std::vector<kasko::api::CrashKey>* crash_keys) {
   // Get the platform annotations.
   std::map<std::string, std::string> annotations;
   internal::GetPlatformCrashpadAnnotations(&annotations);
 
@@ skipping 94 matching lines @@
                                    base::UTF16ToUTF8(value));
 }
 
 void __declspec(dllexport) __cdecl ClearCrashKeyValueImpl(const wchar_t* key) {
   crash_reporter::ClearCrashKey(base::UTF16ToUTF8(key));
 }
 
 }  // extern "C"
 
 #endif  // OS_WIN