Add functionality to prune old crash reports from the database.

client/crash_report_database_mac.mm

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // 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,
@@ skipping 107 matching lines @@
   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:
   //! \brief A private extension of the Report class that maintains bookkeeping
   //!    information of the database.
   struct UploadReport : public Report {
     //! \brief Stores the flock of the file for the duration of
     //!     GetReportForUploading() and RecordUploadAttempt().
     int lock_fd;
   };
 
@@ skipping 331 matching lines @@
       base_dir_.Append(kCompletedDirectory).Append(report_path.BaseName());
   if (rename(report_path.value().c_str(), new_path.value().c_str()) != 0) {
     PLOG(ERROR) << "rename " << report_path.value() << " to "
                 << new_path.value();
     return kFileSystemError;
   }
 
   return kNoError;
 }
 
+CrashReportDatabase::OperationStatus CrashReportDatabaseMac::DeleteReport(
+    const UUID& uuid) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  base::FilePath report_path = LocateCrashReport(uuid);
+  if (report_path.empty())
+    return kReportNotFound;
+
+  base::ScopedFD lock(ObtainReportLock(report_path));
+  if (!lock.is_valid())
+    return kBusyError;
+
+  lock.reset();

[Mark Mentovai, 2015/10/07 03:54:27]

What’s the thinking behind releasing the lock *before* the unlink? Seems
dangerous. Someone else can come in and take the lock and then this function
unlinks the file out from under it.

[Robert Sesek, 2015/10/07 16:24:34]

I didn't expect to be able to unlink() with an flock on the file, but it looks
like you can.

[Mark Mentovai, 2015/10/07 16:40:13]

Robert Sesek wrote:
Yes. POSIX file semantics are cool.

+  if (unlink(report_path.value().c_str()) != 0) {
+    PLOG(ERROR) << "unlink " << report_path.value();
+    return kFileSystemError;
+  }
+
+  return kNoError;
+}
+
 base::FilePath CrashReportDatabaseMac::LocateCrashReport(const UUID& uuid) {
   const std::string target_uuid = uuid.ToString();
   for (size_t i = 0; i < arraysize(kReportDirectories); ++i) {
     base::FilePath path =
        base_dir_.Append(kReportDirectories[i])
                 .Append(target_uuid + "." + kCrashReportFileExtension);
 
     // Test if the path exists.
     struct stat st;
     if (lstat(path.value().c_str(), &st)) {
@@ skipping 113 matching lines @@
     const base::FilePath& path) {
   scoped_ptr<CrashReportDatabaseMac> database_mac(
       new CrashReportDatabaseMac(path));
   if (!database_mac->Initialize())
     database_mac.reset();
 
   return scoped_ptr<CrashReportDatabase>(database_mac.release());
 }
 
 }  // namespace crashpad