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

chrome/browser/crash_upload_list_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 "chrome/browser/crash_upload_list_crashpad.h"
 
 #include <stddef.h>
 
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "components/crash/content/app/crashpad.h"
 
 namespace {
 
 #if defined(OS_WIN)
-typedef void (*GetUploadedReportsPointer)(
-    const crash_reporter::UploadedReport** reports,
+typedef void (*GetCrashReportsPointer)(
+    const crash_reporter::Report** reports,
     size_t* report_count);
 
-void GetUploadedReportsThunk(
-    std::vector<crash_reporter::UploadedReport>* uploaded_reports) {
-  static GetUploadedReportsPointer get_uploaded_reports = []() {
+void GetReportsThunk(
+    std::vector<crash_reporter::Report>* reports) {
+  static GetCrashReportsPointer get_crash_reports = []() {
     HMODULE exe_module = GetModuleHandle(chrome::kBrowserProcessExecutableName);
-    return reinterpret_cast<GetUploadedReportsPointer>(
-        exe_module ? GetProcAddress(exe_module, "GetUploadedReportsImpl")
+    return reinterpret_cast<GetCrashReportsPointer>(
+        exe_module ? GetProcAddress(exe_module, "GetCrashReportsImpl")
                    : nullptr);
   }();
 
-  if (get_uploaded_reports) {
-    const crash_reporter::UploadedReport* reports;
+  if (get_crash_reports) {
+    const crash_reporter::Report* reports_pointer;
     size_t report_count;
-    get_uploaded_reports(&reports, &report_count);
-    *uploaded_reports = std::vector<crash_reporter::UploadedReport>(
-        reports, reports + report_count);
+    get_crash_reports(&reports_pointer, &report_count);
+    *reports = std::vector<crash_reporter::Report>(
+        reports_pointer, reports_pointer + report_count);
   }
 }
 #endif  // OS_WIN
 
+UploadList::UploadInfo::State ReportUploadStateToUploadInfoState(
+    crash_reporter::ReportUploadState state) {
+  switch (state) {
+

[Mark Mentovai, 2016/06/20 21:14:56]

Lose the blank line.

[scottmg, 2016/06/20 21:20:05]

Done.

+    case crash_reporter::ReportUploadState::NotUploaded:
+      return UploadList::UploadInfo::State::NotUploaded;
+
+    case crash_reporter::ReportUploadState::Pending:
+      return UploadList::UploadInfo::State::Pending;
+
+    case crash_reporter::ReportUploadState::Uploaded:
+      return UploadList::UploadInfo::State::Uploaded;
+  }
+
+  NOTREACHED();
+  return UploadList::UploadInfo::State::Uploaded;
+}
+
 }  // namespace
 
 CrashUploadListCrashpad::CrashUploadListCrashpad(
     Delegate* delegate,
     const scoped_refptr<base::SequencedWorkerPool>& worker_pool)
     : CrashUploadList(delegate, base::FilePath(), worker_pool) {}
 
 CrashUploadListCrashpad::~CrashUploadListCrashpad() {}
 
 void CrashUploadListCrashpad::LoadUploadList(
     std::vector<UploadList::UploadInfo>* uploads) {
-  std::vector<crash_reporter::UploadedReport> uploaded_reports;
+  std::vector<crash_reporter::Report> reports;
 #if defined(OS_WIN)
   // On Windows, we only link crash client into chrome.exe (not the dlls), and
   // it does the registration. That means the global that holds the crash report
   // database lives in the .exe, so we need to grab a pointer to a helper in the
-  // exe to get our uploaded reports list.
-  GetUploadedReportsThunk(&uploaded_reports);
+  // exe to get our reports list.
+  GetReportsThunk(&reports);
 #else
-  crash_reporter::GetUploadedReports(&uploaded_reports);
+  crash_reporter::GetReports(&reports);
 #endif
 
-  for (const crash_reporter::UploadedReport& uploaded_report :
-       uploaded_reports) {
+  for (const crash_reporter::Report& report : reports) {
     uploads->push_back(
-        UploadInfo(uploaded_report.remote_id,
-                   base::Time::FromTimeT(uploaded_report.creation_time),
-                   uploaded_report.local_id, base::Time()));
+        UploadInfo(report.remote_id, base::Time::FromTimeT(report.upload_time),
+                   report.local_id, base::Time::FromTimeT(report.capture_time),
+                   ReportUploadStateToUploadInfoState(report.state)));
   }
 }