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);

[Mark Mentovai, 2016/06/20 17:55:21]

This is fine right now, but we may want to add an API to Crashpad to get both
“completed” and “pending” more atomically when possible, since here, we’ll take
the lock and read the metadata two times in succession.

[scottmg, 2016/06/20 21:08:55]

Yup, good point.

+  if (status != crashpad::CrashReportDatabase::kNoError) {
+    return;
+  }
+
   for (const crashpad::CrashReportDatabase::Report& completed_report :
        completed_reports) {
-    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 report;
+    report.local_id = completed_report.uuid.ToString();
+    report.remote_id = completed_report.id;
+    report.creation_time = completed_report.creation_time;
+    report.state = completed_report.uploaded ? ReportUploadState::Uploaded
+                                             : ReportUploadState::NotUploaded;
+    reports->push_back(report);
   }
 
-  std::sort(uploaded_reports->begin(), uploaded_reports->end(),
-            [](const UploadedReport& a, const UploadedReport& b) {
+  for (const crashpad::CrashReportDatabase::Report& pending_report :
+       pending_reports) {
+    Report report;
+    report.local_id = pending_report.uuid.ToString();
+    report.creation_time = pending_report.creation_time;
+    report.state = ReportUploadState::Pending;
+    reports->push_back(report);
+  }
+
+  std::sort(reports->begin(), reports->end(),
+            [](const Report& a, const Report& b) {
               return a.creation_time > b.creation_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 95 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