Add functionality to prune old crash reports from the database.

client/crash_report_database_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.

[Mark Mentovai, 2015/10/07 19:13:05]

Another thing that occurred to me, which can either be fixed under crashpad:22
or its own bug:

If the metadata file gets trashed, we’ll have orphaned reports sitting around on
Windows. We should have something dump all orphaned reports.

[Robert Sesek, 2015/10/07 20:34:52]

That seems like a separate bug.
https://code.google.com/p/crashpad/issues/detail?id=66

 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ skipping 210 matching lines @@
   //! This marks the metadata as dirty, and on destruction, changes will be
   //! written to disk via Write().
   //!
   //! \return #kNoError on success. #kReportNotFound if there was no report with
   //!     the specified UUID. #kBusyError if the report was not in the specified
   //!     state.
   OperationStatus FindSingleReportAndMarkDirty(const UUID& uuid,
                                                ReportState desired_state,
                                                ReportDisk** report_disk);
 
+  //! \brief Removes a report from the metadata database, without touching the
+  //!     on-disk file.
+  //!
+  //! The returned report is only valid if CrashReportDatabase::kNoError is
+  //! returned. This will mark the database as dirty. Future metadata
+  //! operations for this report will not succeed.
+  //!
+  //! \param[in] uuid The report identifier to remove.
+  //! \param[out] report_path The found report's file_path, valid only if
+  //!     CrashReportDatabase::kNoError is returned.
+  OperationStatus DeleteReport(const UUID& uuid,
+                               base::FilePath* report_path);
+
  private:
   Metadata(FileHandle handle, const base::FilePath& report_dir);
 
   bool Rewind();
 
   void Read();
   void Write();
 
   //! \brief Confirms that the corresponding report actually exists on disk
   //!     (that is, the dump file has not been removed), and that the report is
@@ skipping 102 matching lines @@
   if (report_iter == reports_.end())
     return CrashReportDatabase::kReportNotFound;
   OperationStatus os = VerifyReport(*report_iter, desired_state);
   if (os == CrashReportDatabase::kNoError) {
     dirty_ = true;
     *report_disk = &*report_iter;
   }
   return os;
 }
 
+OperationStatus Metadata::DeleteReport(const UUID& uuid,
+                                       base::FilePath* report_path) {
+  auto report_iter = std::find_if(
+      reports_.begin(), reports_.end(), [uuid](const ReportDisk& report) {
+        return report.uuid == uuid;
+      });
+  if (report_iter == reports_.end())
+    return CrashReportDatabase::kReportNotFound;
+  *report_path = report_iter->file_path;
+  reports_.erase(report_iter);
+  dirty_ = true;
+  return CrashReportDatabase::kNoError;
+}
+
 Metadata::Metadata(FileHandle handle, const base::FilePath& report_dir)
     : handle_(handle), report_dir_(report_dir), dirty_(false), reports_() {
 }
 
 bool Metadata::Rewind() {
   FileOffset result = LoggingSeekFile(handle_.get(), 0, SEEK_SET);
   DCHECK_EQ(result, 0);
   return result == 0;
 }
 
@@ skipping 160 matching lines @@
   OperationStatus ErrorWritingCrashReport(NewReport* report) override;
   OperationStatus LookUpCrashReport(const UUID& uuid, Report* report) override;
   OperationStatus GetPendingReports(std::vector<Report>* reports) override;
   OperationStatus GetCompletedReports(std::vector<Report>* reports) override;
   OperationStatus GetReportForUploading(const UUID& uuid,
                                         const Report** report) override;
   OperationStatus RecordUploadAttempt(const Report* report,
                                       bool successful,
                                       const std::string& id) override;
   OperationStatus SkipReportUpload(const UUID& uuid) override;
+  OperationStatus DeleteReport(const UUID& uuid) override;
 
  private:
   scoped_ptr<Metadata> AcquireMetadata();
 
   base::FilePath base_dir_;
   Settings settings_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseWin);
 };
 
 CrashReportDatabaseWin::CrashReportDatabaseWin(const base::FilePath& path)
     : CrashReportDatabase(),
       base_dir_(path),
       settings_(base_dir_.Append(kSettings)),
       initialized_() {
 }
 
 CrashReportDatabaseWin::~CrashReportDatabaseWin() {
 }
 
 bool CrashReportDatabaseWin::Initialize() {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
   // Ensure the database and report subdirectories exist.
   if (!CreateDirectoryIfNecessary(base_dir_) ||
       !CreateDirectoryIfNecessary(base_dir_.Append(kReportsDirectory)))
     return false;
 
-  // TODO(scottmg): When are completed reports pruned from disk? Delete here or
-  // maybe on AcquireMetadata().
-
   if (!settings_.Initialize())
     return false;
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 Settings* CrashReportDatabaseWin::GetSettings() {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &settings_;
@@ skipping 146 matching lines @@
     report_disk->state =
         successful ? ReportState::kCompleted : ReportState::kPending;
   }
 
   // Call Settings::SetLastUploadAttemptTime().
   // https://code.google.com/p/crashpad/issues/detail?id=13.
 
   return os;
 }
 
+OperationStatus CrashReportDatabaseWin::DeleteReport(const UUID& uuid) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  scoped_ptr<Metadata> metadata(AcquireMetadata());
+  if (!metadata)
+    return kDatabaseError;
+
+  base::FilePath report_path;
+  OperationStatus os = metadata->DeleteReport(uuid, &report_path);
+  if (os != kNoError)
+    return os;
+
+  if (!DeleteFile(report_path.value().c_str())) {
+    PLOG(ERROR) << "DeleteFile "
+                << base::UTF16ToUTF8(report_path.value());
+    return kFileSystemError;
+  }
+  return kNoError;
+}
+
 OperationStatus CrashReportDatabaseWin::SkipReportUpload(const UUID& uuid) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   if (!metadata)
     return kDatabaseError;
   ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReportAndMarkDirty(
       uuid, ReportState::kPending, &report_disk);
   if (os == CrashReportDatabase::kNoError)
@@ skipping 11 matching lines @@
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
   scoped_ptr<CrashReportDatabaseWin> database_win(
       new CrashReportDatabaseWin(path));
   return database_win->Initialize() ? database_win.Pass()
                                     : scoped_ptr<CrashReportDatabaseWin>();
 }
 
 }  // namespace crashpad